{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J8rO9PtPsDKF"
   },
   "source": [
    "## BERT on SQUAD Dataset\n",
    "---------------\n",
    "* Most of the code is taken referance from google-research \n",
    "* The bert model is **fine-tuned** only.\n",
    "* Code has been modified as per necesscity\n",
    "* Used the **bert uncased_L-12_H-768_A-12** model\n",
    "* All the referance are mentioned in the referances section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-iAQg8q1MZIc"
   },
   "outputs": [],
   "source": [
    "# importing all necessary files\n",
    "\n",
    "import zipfile\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "import sys\n",
    "import datetime\n",
    "import tensorflow as tf\n",
    "import os\n",
    "import json\n",
    "import six\n",
    "\n",
    "from collections import Counter\n",
    "import string\n",
    "import re\n",
    "import argparse\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8EvhfJDfbKM7"
   },
   "source": [
    "## Configuring TPU\n",
    "\n",
    "This section, you perform the following tasks:\n",
    "  * Set up a Colab TPU running environment\n",
    "  * Verify that you are connected to a TPU device\n",
    "\n",
    "Once done. Upload your credentials to TPU to access your GCS bucket."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 391
    },
    "colab_type": "code",
    "id": "pUX8reoFHGk4",
    "outputId": "6367eead-26c7-484a-a8a3-c84bcf6cd8dd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TPU address is grpc://10.12.236.42:8470\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0827 05:51:10.907844 140491252946816 lazy_loader.py:50] \n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TPU devices:\n",
      "[_DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:CPU:0, CPU, -1, 11440417705514041917),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 17179869184, 11361402579519159698),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:0, TPU, 17179869184, 12357697597335777241),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:1, TPU, 17179869184, 7898279176896720777),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:2, TPU, 17179869184, 16769548510779700091),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:3, TPU, 17179869184, 9684062799403801468),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:4, TPU, 17179869184, 18088205161317314166),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:5, TPU, 17179869184, 2719725766142665814),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:6, TPU, 17179869184, 12910852574047901557),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:7, TPU, 17179869184, 9410472538681109359),\n",
      " _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 8589934592, 15068353228979054653)]\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "import json\n",
    "import os\n",
    "import pprint\n",
    "import random\n",
    "import string\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "\n",
    "assert 'COLAB_TPU_ADDR' in os.environ, 'ERROR: Not connected to a TPU runtime; please see the first cell in this notebook for instructions!'\n",
    "TPU_ADDRESS = 'grpc://' + os.environ['COLAB_TPU_ADDR']\n",
    "print('TPU address is', TPU_ADDRESS)\n",
    "\n",
    "from google.colab import auth\n",
    "auth.authenticate_user()\n",
    "with tf.Session(TPU_ADDRESS) as session:\n",
    "  print('TPU devices:')\n",
    "  pprint.pprint(session.list_devices())\n",
    "\n",
    "  # Upload credentials to TPU.\n",
    "  with open('/content/adc.json', 'r') as f:\n",
    "    auth_info = json.load(f)\n",
    "  tf.contrib.cloud.configure_gcs(session, credentials=auth_info)\n",
    "  # Now credentials are set for all future sessions on this TPU."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KcQLA51nosTN"
   },
   "source": [
    "**import necessary BERT modules**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 156
    },
    "colab_type": "code",
    "id": "3ZEclFB0Hbyz",
    "outputId": "970acfc1-5173-42ad-a352-463560191cc4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cloning into 'bert_repo'...\n",
      "remote: Enumerating objects: 333, done.\u001b[K\n",
      "remote: Total 333 (delta 0), reused 0 (delta 0), pack-reused 333\u001b[K\n",
      "Receiving objects: 100% (333/333), 282.46 KiB | 3.98 MiB/s, done.\n",
      "Resolving deltas: 100% (183/183), done.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0827 06:05:06.749072 140491252946816 deprecation_wrapper.py:119] From bert_repo/optimization.py:87: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "!test -d bert_repo || git clone https://github.com/google-research/bert bert_repo\n",
    "if not 'bert_repo' in sys.path:\n",
    "  sys.path += ['bert_repo']\n",
    "\n",
    "# import python modules defined by BERT\n",
    "import run_squad\n",
    "import modeling\n",
    "import optimization\n",
    "import tokenization\n",
    "import tensorflow as tf\n",
    "import tokenization\n",
    "\n",
    "# import tfhub \n",
    "import tensorflow_hub as hub"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YQk3_1S8o8at"
   },
   "source": [
    "**This next section of code performs the following tasks:**\n",
    "\n",
    "*  Specify BERT pretrained model [uncased_L-12_H-768_A-12]\n",
    "*  Create output directory for model checkpoints and eval results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "cellView": "both",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "6a4ShppsH_N9",
    "outputId": "967157cb-a37d-4290-b23a-79016219092f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***** Model output directory: gs://bert-on-squad/bert-tfhub/models/SQUAD *****\n"
     ]
    }
   ],
   "source": [
    "TASK = 'SQUAD' #@param {type:\"string\"}\n",
    "assert TASK in ('MRPC', 'CoLA',\"SQUAD\"), 'Only (MRPC, CoLA) are demonstrated here.'\n",
    "\n",
    "\n",
    "BUCKET = 'bert-on-squad' #@param {type:\"string\"}\n",
    "assert BUCKET, 'Must specify an existing GCS bucket name'\n",
    "OUTPUT_DIR = 'gs://{}/bert-tfhub/models/{}'.format(BUCKET, TASK)\n",
    "tf.gfile.MakeDirs(OUTPUT_DIR)\n",
    "print('***** Model output directory: {} *****'.format(OUTPUT_DIR))\n",
    "\n",
    "# Available pretrained model checkpoints:\n",
    "#   uncased_L-12_H-768_A-12: uncased BERT base model\n",
    "#   uncased_L-24_H-1024_A-16: uncased BERT large model\n",
    "#   cased_L-12_H-768_A-12: cased BERT large model\n",
    "BERT_MODEL = 'uncased_L-12_H-768_A-12' #@param {type:\"string\"}\n",
    "BERT_MODEL_HUB = 'https://tfhub.dev/google/bert_' + BERT_MODEL + '/1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OA0Qj3h_NNY3"
   },
   "outputs": [],
   "source": [
    "# Setup TPU related config\n",
    "tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(TPU_ADDRESS)\n",
    "NUM_TPU_CORES = 8\n",
    "ITERATIONS_PER_LOOP = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 136
    },
    "colab_type": "code",
    "id": "eNKaOOjHOXNB",
    "outputId": "19be3601-9673-4506-e45a-d83a1f6cae06"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***** BERT pretrained directory: gs://cloud-tpu-checkpoints/bert/uncased_L-12_H-768_A-12 *****\n",
      "gs://cloud-tpu-checkpoints/bert/uncased_L-12_H-768_A-12/bert_config.json\n",
      "gs://cloud-tpu-checkpoints/bert/uncased_L-12_H-768_A-12/bert_model.ckpt.data-00000-of-00001\n",
      "gs://cloud-tpu-checkpoints/bert/uncased_L-12_H-768_A-12/bert_model.ckpt.index\n",
      "gs://cloud-tpu-checkpoints/bert/uncased_L-12_H-768_A-12/bert_model.ckpt.meta\n",
      "gs://cloud-tpu-checkpoints/bert/uncased_L-12_H-768_A-12/checkpoint\n",
      "gs://cloud-tpu-checkpoints/bert/uncased_L-12_H-768_A-12/vocab.txt\n"
     ]
    }
   ],
   "source": [
    "# Setup task specific model and TPU running config.\n",
    "BERT_PRETRAINED_DIR = 'gs://cloud-tpu-checkpoints/bert/' + BERT_MODEL \n",
    "print('***** BERT pretrained directory: {} *****'.format(BERT_PRETRAINED_DIR))\n",
    "!gsutil ls $BERT_PRETRAINED_DIR\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8MdBSAQDPNej"
   },
   "outputs": [],
   "source": [
    "# seting up necessary path files for models\n",
    "CONFIG_FILE = os.path.join(BERT_PRETRAINED_DIR, 'bert_config.json')\n",
    "INIT_CHECKPOINT = os.path.join(BERT_PRETRAINED_DIR, 'bert_model.ckpt')\n",
    "VOCAB_FILE = os.path.join(BERT_PRETRAINED_DIR, 'vocab.txt')\n",
    "DO_LOWER_CASE = BERT_MODEL.startswith('uncased')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "98wc25FnPp4A"
   },
   "outputs": [],
   "source": [
    "OUTPUT_DIR = OUTPUT_DIR.replace('bert-tfhub', 'bert-checkpoints')\n",
    "tf.gfile.MakeDirs(OUTPUT_DIR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WAExipC-bF60"
   },
   "source": [
    "## Get SQUAD Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CPNBY2ekdrqr"
   },
   "outputs": [],
   "source": [
    "with zipfile.ZipFile(\"/content/train-v1.1.json.zip\",\"r\") as zip_ref:\n",
    "    zip_ref.extractall()\n",
    "    \n",
    "with zipfile.ZipFile(\"/content/dev-v1.1.json.zip\",\"r\") as zip_ref:\n",
    "    zip_ref.extractall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oWIyWoKvsYPs"
   },
   "source": [
    "### Important Functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DQITcyy8s8yc"
   },
   "source": [
    "**read_squad_examples :**\n",
    "This function takes input as **json** file and retunrs the object of SquadExample claas. Which is nothing but, container storinng our each data point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZN_YXPZrcL3l"
   },
   "outputs": [],
   "source": [
    "def read_squad_examples(input_file, is_training):\n",
    "  \"\"\"Read a SQuAD json file into a list of SquadExample.\"\"\"\n",
    "  with tf.gfile.Open(input_file, \"r\") as reader:\n",
    "    input_data = json.load(reader)[\"data\"]\n",
    "\n",
    "  def is_whitespace(c):\n",
    "    if c == \" \" or c == \"\\t\" or c == \"\\r\" or c == \"\\n\" or ord(c) == 0x202F:\n",
    "      return True\n",
    "    return False\n",
    "\n",
    "  examples = []\n",
    "  for entry in input_data:\n",
    "    for paragraph in entry[\"paragraphs\"]:\n",
    "      paragraph_text = paragraph[\"context\"]\n",
    "      doc_tokens = []\n",
    "      char_to_word_offset = []\n",
    "      prev_is_whitespace = True\n",
    "      for c in paragraph_text:\n",
    "        if is_whitespace(c):\n",
    "          prev_is_whitespace = True\n",
    "        else:\n",
    "          if prev_is_whitespace:\n",
    "            doc_tokens.append(c)\n",
    "          else:\n",
    "            doc_tokens[-1] += c\n",
    "          prev_is_whitespace = False\n",
    "        char_to_word_offset.append(len(doc_tokens) - 1)\n",
    "\n",
    "      for qa in paragraph[\"qas\"]:\n",
    "        qas_id = qa[\"id\"]\n",
    "        question_text = qa[\"question\"]\n",
    "        start_position = None\n",
    "        end_position = None\n",
    "        orig_answer_text = None\n",
    "        is_impossible = False\n",
    "        if is_training:\n",
    "\n",
    "          if False:\n",
    "            is_impossible = qa[\"is_impossible\"]\n",
    "          if (len(qa[\"answers\"]) != 1) and (not is_impossible):\n",
    "            raise ValueError(\n",
    "                \"For training, each question should have exactly 1 answer.\")\n",
    "          if not is_impossible:\n",
    "            answer = qa[\"answers\"][0]\n",
    "            orig_answer_text = answer[\"text\"]\n",
    "            answer_offset = answer[\"answer_start\"]\n",
    "            answer_length = len(orig_answer_text)\n",
    "            start_position = char_to_word_offset[answer_offset]\n",
    "            end_position = char_to_word_offset[answer_offset + answer_length -\n",
    "                                               1]\n",
    "            # Only add answers where the text can be exactly recovered from the\n",
    "            # document. If this CAN'T happen it's likely due to weird Unicode\n",
    "            # stuff so we will just skip the example.\n",
    "            #\n",
    "            # Note that this means for training mode, every example is NOT\n",
    "            # guaranteed to be preserved.\n",
    "            actual_text = \" \".join(\n",
    "                doc_tokens[start_position:(end_position + 1)])\n",
    "            cleaned_answer_text = \" \".join(\n",
    "                tokenization.whitespace_tokenize(orig_answer_text))\n",
    "            if actual_text.find(cleaned_answer_text) == -1:\n",
    "              tf.logging.warning(\"Could not find answer: '%s' vs. '%s'\",\n",
    "                                 actual_text, cleaned_answer_text)\n",
    "              continue\n",
    "          else:\n",
    "            start_position = -1\n",
    "            end_position = -1\n",
    "            orig_answer_text = \"\"\n",
    "\n",
    "        example = run_squad.SquadExample(\n",
    "            qas_id=qas_id,\n",
    "            question_text=question_text,\n",
    "            doc_tokens=doc_tokens,\n",
    "            orig_answer_text=orig_answer_text,\n",
    "            start_position=start_position,\n",
    "            end_position=end_position,\n",
    "            is_impossible=is_impossible)\n",
    "        examples.append(example)\n",
    "\n",
    "  return examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "eyZubuOEc1YE",
    "outputId": "c7f179b4-471d-463c-8ea1-79d8a0b24783"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total train examples are  87599\n"
     ]
    }
   ],
   "source": [
    "train_examples = read_squad_examples(\"/content/train-v1.1.json\",True)\n",
    "print(\"Total train examples are \",len(train_examples))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 258
    },
    "colab_type": "code",
    "id": "wtx6cVPdrsL9",
    "outputId": "29579dba-0e85-4b6d-85c2-5d4d7a017617"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of return :\n",
      " <class 'run_squad.SquadExample'>\n",
      "************************************************************\n",
      "Question ID :  5733be284776f41900661182\n",
      "************************************************************\n",
      "question_text :  To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France?\n",
      "************************************************************\n",
      "doc_tokens :  ['Architecturally,', 'the', 'school', 'has', 'a', 'Catholic', 'character.', 'Atop', 'the', 'Main', \"Building's\", 'gold', 'dome', 'is', 'a', 'golden', 'statue', 'of', 'the', 'Virgin', 'Mary.', 'Immediately', 'in', 'front', 'of', 'the', 'Main', 'Building', 'and', 'facing', 'it,', 'is', 'a', 'copper', 'statue', 'of', 'Christ', 'with', 'arms', 'upraised', 'with', 'the', 'legend', '\"Venite', 'Ad', 'Me', 'Omnes\".', 'Next', 'to', 'the', 'Main', 'Building', 'is', 'the', 'Basilica', 'of', 'the', 'Sacred', 'Heart.', 'Immediately', 'behind', 'the', 'basilica', 'is', 'the', 'Grotto,', 'a', 'Marian', 'place', 'of', 'prayer', 'and', 'reflection.', 'It', 'is', 'a', 'replica', 'of', 'the', 'grotto', 'at', 'Lourdes,', 'France', 'where', 'the', 'Virgin', 'Mary', 'reputedly', 'appeared', 'to', 'Saint', 'Bernadette', 'Soubirous', 'in', '1858.', 'At', 'the', 'end', 'of', 'the', 'main', 'drive', '(and', 'in', 'a', 'direct', 'line', 'that', 'connects', 'through', '3', 'statues', 'and', 'the', 'Gold', 'Dome),', 'is', 'a', 'simple,', 'modern', 'stone', 'statue', 'of', 'Mary.']\n",
      "************************************************************\n",
      "start_position :  90\n",
      "end_position :  92\n",
      "************************************************************\n",
      "is_impossible :  False\n"
     ]
    }
   ],
   "source": [
    "print(\"Type of return :\\n\",type(train_examples[0]))\n",
    "print(\"*\"*60)\n",
    "print(\"Question ID : \",train_examples[0].qas_id)\n",
    "print(\"*\"*60)\n",
    "print(\"question_text : \",train_examples[0].question_text)\n",
    "print(\"*\"*60)\n",
    "print(\"doc_tokens : \",train_examples[0].doc_tokens)\n",
    "print(\"*\"*60)\n",
    "print(\"start_position : \",train_examples[0].start_position)\n",
    "print(\"end_position : \",train_examples[0].end_position)\n",
    "print(\"*\"*60)\n",
    "print(\"is_impossible : \",train_examples[0].is_impossible)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Write Predicitons :**\n",
    "\n",
    "This funciton is used to write predictions to output file provided. It internally uses get_final_text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jCiPOA7tMPkW"
   },
   "outputs": [],
   "source": [
    "def get_final_text(pred_text, orig_text, do_lower_case):\n",
    "  \"\"\"Project the tokenized prediction back to the original text.\"\"\"\n",
    "\n",
    "  def _strip_spaces(text):\n",
    "    ns_chars = []\n",
    "    ns_to_s_map = collections.OrderedDict()\n",
    "    for (i, c) in enumerate(text):\n",
    "      if c == \" \":\n",
    "        continue\n",
    "      ns_to_s_map[len(ns_chars)] = i\n",
    "      ns_chars.append(c)\n",
    "    ns_text = \"\".join(ns_chars)\n",
    "    return (ns_text, ns_to_s_map)\n",
    "\n",
    "  # We first tokenize `orig_text`, strip whitespace from the result\n",
    "  # and `pred_text`, and check if they are the same length. If they are\n",
    "  # NOT the same length, the heuristic has failed. If they are the same\n",
    "  # length, we assume the characters are one-to-one aligned.\n",
    "  tokenizer = tokenization.BasicTokenizer(do_lower_case=do_lower_case)\n",
    "\n",
    "  tok_text = \" \".join(tokenizer.tokenize(orig_text))\n",
    "\n",
    "  start_position = tok_text.find(pred_text)\n",
    "  if start_position == -1:\n",
    "    if True:\n",
    "      tf.logging.info(\n",
    "          \"Unable to find text: '%s' in '%s'\" % (pred_text, orig_text))\n",
    "    return orig_text\n",
    "  end_position = start_position + len(pred_text) - 1\n",
    "\n",
    "  (orig_ns_text, orig_ns_to_s_map) = _strip_spaces(orig_text)\n",
    "  (tok_ns_text, tok_ns_to_s_map) = _strip_spaces(tok_text)\n",
    "\n",
    "  if len(orig_ns_text) != len(tok_ns_text):\n",
    "    if True:\n",
    "      tf.logging.info(\"Length not equal after stripping spaces: '%s' vs '%s'\",\n",
    "                      orig_ns_text, tok_ns_text)\n",
    "    return orig_text\n",
    "\n",
    "  # We then project the characters in `pred_text` back to `orig_text` using\n",
    "  # the character-to-character alignment.\n",
    "  tok_s_to_ns_map = {}\n",
    "  for (i, tok_index) in six.iteritems(tok_ns_to_s_map):\n",
    "    tok_s_to_ns_map[tok_index] = i\n",
    "\n",
    "  orig_start_position = None\n",
    "  if start_position in tok_s_to_ns_map:\n",
    "    ns_start_position = tok_s_to_ns_map[start_position]\n",
    "    if ns_start_position in orig_ns_to_s_map:\n",
    "      orig_start_position = orig_ns_to_s_map[ns_start_position]\n",
    "\n",
    "  if orig_start_position is None:\n",
    "    if True:\n",
    "      tf.logging.info(\"Couldn't map start position\")\n",
    "    return orig_text\n",
    "\n",
    "  orig_end_position = None\n",
    "  if end_position in tok_s_to_ns_map:\n",
    "    ns_end_position = tok_s_to_ns_map[end_position]\n",
    "    if ns_end_position in orig_ns_to_s_map:\n",
    "      orig_end_position = orig_ns_to_s_map[ns_end_position]\n",
    "\n",
    "  if orig_end_position is None:\n",
    "    if True:\n",
    "      tf.logging.info(\"Couldn't map end position\")\n",
    "    return orig_text\n",
    "\n",
    "  output_text = orig_text[orig_start_position:(orig_end_position + 1)]\n",
    "  return output_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QFm7pZtk8a3L"
   },
   "outputs": [],
   "source": [
    "def write_predictions(all_examples, all_features, all_results, n_best_size,\n",
    "                      max_answer_length, do_lower_case, output_prediction_file,\n",
    "                      output_nbest_file, output_null_log_odds_file):\n",
    "  \"\"\"Write final predictions to the json file and log-odds of null if needed.\"\"\"\n",
    "  \n",
    "  tf.logging.info(\"Writing predictions to: %s\" % (output_prediction_file))\n",
    "  tf.logging.info(\"Writing nbest to: %s\" % (output_nbest_file))\n",
    "\n",
    "  example_index_to_features = collections.defaultdict(list)\n",
    "  for feature in all_features:\n",
    "    example_index_to_features[feature.example_index].append(feature)\n",
    "\n",
    "  unique_id_to_result = {}\n",
    "  for result in all_results:\n",
    "    unique_id_to_result[result.unique_id] = result\n",
    "\n",
    "  _PrelimPrediction = collections.namedtuple(  # pylint: disable=invalid-name\n",
    "      \"PrelimPrediction\",\n",
    "      [\"feature_index\", \"start_index\", \"end_index\", \"start_logit\", \"end_logit\"])\n",
    "\n",
    "  all_predictions = collections.OrderedDict()\n",
    "  all_nbest_json = collections.OrderedDict()\n",
    "  scores_diff_json = collections.OrderedDict()\n",
    "\n",
    "  for (example_index, example) in enumerate(all_examples):\n",
    "    features = example_index_to_features[example_index]\n",
    "\n",
    "    prelim_predictions = []\n",
    "    # keep track of the minimum score of null start+end of position 0\n",
    "    score_null = 1000000  # large and positive\n",
    "    min_null_feature_index = 0  # the paragraph slice with min mull score\n",
    "    null_start_logit = 0  # the start logit at the slice with min null score\n",
    "    null_end_logit = 0  # the end logit at the slice with min null score\n",
    "    for (feature_index, feature) in enumerate(features):\n",
    "      result = unique_id_to_result[feature.unique_id]\n",
    "      start_indexes = run_squad._get_best_indexes(result.start_logits, n_best_size)\n",
    "      end_indexes = run_squad._get_best_indexes(result.end_logits, n_best_size)\n",
    "      # if we could have irrelevant answers, get the min score of irrelevant\n",
    "      if False:\n",
    "        feature_null_score = result.start_logits[0] + result.end_logits[0]\n",
    "        if feature_null_score < score_null:\n",
    "          score_null = feature_null_score\n",
    "          min_null_feature_index = feature_index\n",
    "          null_start_logit = result.start_logits[0]\n",
    "          null_end_logit = result.end_logits[0]\n",
    "      for start_index in start_indexes:\n",
    "        for end_index in end_indexes:\n",
    "          # We could hypothetically create invalid predictions, e.g., predict\n",
    "          # that the start of the span is in the question. We throw out all\n",
    "          # invalid predictions.\n",
    "          if start_index >= len(feature.tokens):\n",
    "            continue\n",
    "          if end_index >= len(feature.tokens):\n",
    "            continue\n",
    "          if start_index not in feature.token_to_orig_map:\n",
    "            continue\n",
    "          if end_index not in feature.token_to_orig_map:\n",
    "            continue\n",
    "          if not feature.token_is_max_context.get(start_index, False):\n",
    "            continue\n",
    "          if end_index < start_index:\n",
    "            continue\n",
    "          length = end_index - start_index + 1\n",
    "          if length > max_answer_length:\n",
    "            continue\n",
    "          prelim_predictions.append(\n",
    "              _PrelimPrediction(\n",
    "                  feature_index=feature_index,\n",
    "                  start_index=start_index,\n",
    "                  end_index=end_index,\n",
    "                  start_logit=result.start_logits[start_index],\n",
    "                  end_logit=result.end_logits[end_index]))\n",
    "\n",
    "    if False:\n",
    "      prelim_predictions.append(\n",
    "          _PrelimPrediction(\n",
    "              feature_index=min_null_feature_index,\n",
    "              start_index=0,\n",
    "              end_index=0,\n",
    "              start_logit=null_start_logit,\n",
    "              end_logit=null_end_logit))\n",
    "    prelim_predictions = sorted(\n",
    "        prelim_predictions,\n",
    "        key=lambda x: (x.start_logit + x.end_logit),\n",
    "        reverse=True)\n",
    "\n",
    "    _NbestPrediction = collections.namedtuple(  # pylint: disable=invalid-name\n",
    "        \"NbestPrediction\", [\"text\", \"start_logit\", \"end_logit\"])\n",
    "\n",
    "    seen_predictions = {}\n",
    "    nbest = []\n",
    "    for pred in prelim_predictions:\n",
    "      if len(nbest) >= n_best_size:\n",
    "        break\n",
    "      feature = features[pred.feature_index]\n",
    "      if pred.start_index > 0:  # this is a non-null prediction\n",
    "        tok_tokens = feature.tokens[pred.start_index:(pred.end_index + 1)]\n",
    "        orig_doc_start = feature.token_to_orig_map[pred.start_index]\n",
    "        orig_doc_end = feature.token_to_orig_map[pred.end_index]\n",
    "        orig_tokens = example.doc_tokens[orig_doc_start:(orig_doc_end + 1)]\n",
    "        tok_text = \" \".join(tok_tokens)\n",
    "\n",
    "        # De-tokenize WordPieces that have been split off.\n",
    "        tok_text = tok_text.replace(\" ##\", \"\")\n",
    "        tok_text = tok_text.replace(\"##\", \"\")\n",
    "\n",
    "        # Clean whitespace\n",
    "        tok_text = tok_text.strip()\n",
    "        tok_text = \" \".join(tok_text.split())\n",
    "        orig_text = \" \".join(orig_tokens)\n",
    "\n",
    "        final_text = get_final_text(tok_text, orig_text, do_lower_case)\n",
    "        if final_text in seen_predictions:\n",
    "          continue\n",
    "\n",
    "        seen_predictions[final_text] = True\n",
    "      else:\n",
    "        final_text = \"\"\n",
    "        seen_predictions[final_text] = True\n",
    "\n",
    "      nbest.append(\n",
    "          _NbestPrediction(\n",
    "              text=final_text,\n",
    "              start_logit=pred.start_logit,\n",
    "              end_logit=pred.end_logit))\n",
    "\n",
    "    # if we didn't inlude the empty option in the n-best, inlcude it\n",
    "    if False:\n",
    "      if \"\" not in seen_predictions:\n",
    "        nbest.append(\n",
    "            _NbestPrediction(\n",
    "                text=\"\", start_logit=null_start_logit,\n",
    "                end_logit=null_end_logit))\n",
    "    # In very rare edge cases we could have no valid predictions. So we\n",
    "    # just create a nonce prediction in this case to avoid failure.\n",
    "    if not nbest:\n",
    "      nbest.append(\n",
    "          _NbestPrediction(text=\"empty\", start_logit=0.0, end_logit=0.0))\n",
    "\n",
    "    assert len(nbest) >= 1\n",
    "\n",
    "    total_scores = []\n",
    "    best_non_null_entry = None\n",
    "    for entry in nbest:\n",
    "      total_scores.append(entry.start_logit + entry.end_logit)\n",
    "      if not best_non_null_entry:\n",
    "        if entry.text:\n",
    "          best_non_null_entry = entry\n",
    "\n",
    "    probs = run_squad._compute_softmax(total_scores)\n",
    "\n",
    "    nbest_json = []\n",
    "    for (i, entry) in enumerate(nbest):\n",
    "      output = collections.OrderedDict()\n",
    "      output[\"text\"] = entry.text\n",
    "      output[\"probability\"] = probs[i]\n",
    "      output[\"start_logit\"] = entry.start_logit\n",
    "      output[\"end_logit\"] = entry.end_logit\n",
    "      nbest_json.append(output)\n",
    "\n",
    "    assert len(nbest_json) >= 1\n",
    "\n",
    "    if not False:\n",
    "      all_predictions[example.qas_id] = nbest_json[0][\"text\"]\n",
    "    else:\n",
    "      # predict \"\" iff the null score - the score of best non-null > threshold\n",
    "      score_diff = score_null - best_non_null_entry.start_logit - (\n",
    "          best_non_null_entry.end_logit)\n",
    "      scores_diff_json[example.qas_id] = score_diff\n",
    "      if score_diff > 0.0:\n",
    "        all_predictions[example.qas_id] = \"\"\n",
    "      else:\n",
    "        all_predictions[example.qas_id] = best_non_null_entry.text\n",
    "\n",
    "    all_nbest_json[example.qas_id] = nbest_json\n",
    "\n",
    "  with tf.gfile.GFile(output_prediction_file, \"w\") as writer:\n",
    "    writer.write(json.dumps(all_predictions, indent=4) + \"\\n\")\n",
    "\n",
    "  with tf.gfile.GFile(output_nbest_file, \"w\") as writer:\n",
    "    writer.write(json.dumps(all_nbest_json, indent=4) + \"\\n\")\n",
    "\n",
    "  if False:\n",
    "    with tf.gfile.GFile(output_null_log_odds_file, \"w\") as writer:\n",
    "      writer.write(json.dumps(scores_diff_json, indent=4) + \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7t1tO4T2rkxW"
   },
   "source": [
    "**Model Parameters**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "i4lgBNxxeRFO"
   },
   "outputs": [],
   "source": [
    "# Model Hyper Parameters\n",
    "TRAIN_BATCH_SIZE = 16\n",
    "LEARNING_RATE = 3e-5\n",
    "NUM_TRAIN_EPOCHS = 2.0\n",
    "WARMUP_PROPORTION = 0.1\n",
    "MAX_SEQ_LENGTH = 256\n",
    "EVAL_BATCH_SIZE = 8\n",
    "\n",
    "tpu_cluster_resolver = None\n",
    "SAVE_CHECKPOINTS_STEPS = 1000\n",
    "ITERATIONS_PER_LOOP = 1000\n",
    "NUM_TPU_CORES = 8\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iQLBq4mDtXLY"
   },
   "source": [
    "**Tokenizer**:\n",
    "\n",
    "Takes vocab file as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MWyjV9dReFNG"
   },
   "outputs": [],
   "source": [
    "tokenizer = tokenization.FullTokenizer(vocab_file=VOCAB_FILE, do_lower_case=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tokenization examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this',\n",
       " 'is',\n",
       " 'a',\n",
       " 'different',\n",
       " 'and',\n",
       " 'longer',\n",
       " 'example',\n",
       " 'to',\n",
       " 'check',\n",
       " 'the',\n",
       " \"'\",\n",
       " 'token',\n",
       " '##ization',\n",
       " \"'\",\n",
       " '.']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.tokenize(\"This is a different and longer example to check the 'Tokenization'.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Qe8kzaZqthS6",
    "outputId": "2f3b1eee-c506-42c1-b6c1-79e06694066c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is', 'demo', 'example', 'for', 'token', '##izer']"
      ]
     },
     "execution_count": 28,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.tokenize(\"this is demo example for tokenizer\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FaOHcUDHeXGm"
   },
   "outputs": [],
   "source": [
    "num_train_steps = int(\n",
    "    len(train_examples) / TRAIN_BATCH_SIZE * NUM_TRAIN_EPOCHS)\n",
    "num_warmup_steps = int(num_train_steps * WARMUP_PROPORTION)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TMQEPmSvgar0"
   },
   "outputs": [],
   "source": [
    "# Setup TPU related config\n",
    "tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(TPU_ADDRESS)\n",
    "NUM_TPU_CORES = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JzzE4xH5ubyM"
   },
   "source": [
    "**model function builds model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DD5amWrgenU-"
   },
   "outputs": [],
   "source": [
    "model_fn = run_squad.model_fn_builder(\n",
    "    bert_config=modeling.BertConfig.from_json_file(CONFIG_FILE),\n",
    "    init_checkpoint=INIT_CHECKPOINT,\n",
    "    learning_rate=LEARNING_RATE,\n",
    "    num_train_steps=num_train_steps,\n",
    "    num_warmup_steps=num_warmup_steps,\n",
    "    use_tpu=True, #If False training will fall on CPU or GPU, depending on what is available  \n",
    "    use_one_hot_embeddings=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "d-TnyzNUe48M"
   },
   "outputs": [],
   "source": [
    "run_config = tf.contrib.tpu.RunConfig(\n",
    "    cluster=tpu_cluster_resolver,\n",
    "    model_dir=OUTPUT_DIR,\n",
    "    save_checkpoints_steps=SAVE_CHECKPOINTS_STEPS,\n",
    "    tpu_config=tf.contrib.tpu.TPUConfig(\n",
    "        iterations_per_loop=ITERATIONS_PER_LOOP,\n",
    "        num_shards=NUM_TPU_CORES,\n",
    "        per_host_input_for_training=tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "7jE3VBLFe_S-",
    "outputId": "f811dbd2-b6ba-44f1-dc95-cc087a42183c"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0827 06:18:43.056533 140491252946816 estimator.py:1984] Estimator's model_fn (<function model_fn_builder.<locals>.model_fn at 0x7fc65e7fe950>) includes params argument, but params are not passed to Estimator.\n"
     ]
    }
   ],
   "source": [
    "estimator = tf.contrib.tpu.TPUEstimator(\n",
    "    use_tpu=True, #If False training will fall on CPU or GPU, depending on what is available \n",
    "    model_fn=model_fn,\n",
    "    config=run_config,\n",
    "    train_batch_size=TRAIN_BATCH_SIZE,\n",
    "    predict_batch_size=EVAL_BATCH_SIZE,\n",
    "    eval_batch_size=EVAL_BATCH_SIZE)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 88
    },
    "colab_type": "code",
    "id": "DPtSzrrqfQB_",
    "outputId": "3ddc953b-28bc-49c9-81bd-1346ba9f9612"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0827 06:18:46.242335 140491252946816 deprecation_wrapper.py:119] From bert_repo/run_squad.py:1065: The name tf.python_io.TFRecordWriter is deprecated. Please use tf.io.TFRecordWriter instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please wait...\n"
     ]
    }
   ],
   "source": [
    "print('Please wait...')\n",
    "train_writer = run_squad.FeatureWriter(\n",
    "        filename=os.path.join(OUTPUT_DIR, \"train.tf_record\"),\n",
    "        is_training=True)\n",
    "\n",
    "\n",
    "def append_feature(feature):\n",
    "  train_features.append(feature)\n",
    "  train_writer.process_feature(feature)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sRX_QJF2ZlSE"
   },
   "source": [
    "### convert_examples_to_features\n",
    "\n",
    "This function converts train examples got from read_squad_examples to features that can be fed to BERT model. It returns all features in InputFeatures class object.\n",
    "\n",
    "**Input Feature class schema:**\n",
    "\n",
    "    unique_id,<br>\n",
    "    example_index,<br>\n",
    "    doc_span_index,<br>\n",
    "    tokens,<br>\n",
    "    token_to_orig_map,<br>\n",
    "    token_is_max_context,<br>\n",
    "    input_ids,<br>\n",
    "    input_mask,<br>\n",
    "    segment_ids,<br>\n",
    "    start_position=None,<br>\n",
    "    end_position=None,<br>\n",
    "    is_impossible=None<br>\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "jyv03G3YfZUr",
    "outputId": "fcbcf838-d72d-497d-8a1a-56210481b3fe"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0827 06:18:47.903628 140491252946816 deprecation_wrapper.py:119] From bert_repo/run_squad.py:431: The name tf.logging.info is deprecated. Please use tf.compat.v1.logging.info instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train_features = []\n",
    "\n",
    "run_squad.convert_examples_to_features(train_examples, tokenizer, MAX_SEQ_LENGTH, 128, 64, True, output_fn=append_feature)\n",
    "\n",
    "train_writer.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 530
    },
    "colab_type": "code",
    "id": "1NgUx1icdmQ8",
    "outputId": "ffa2dbc4-113b-4a48-fef6-81e12ab6bab0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example to feature :\n",
      "<class 'run_squad.InputFeatures'>\n",
      "----------------------------------------------------------------------\n",
      "unique_id :  1000000000\n",
      "----------------------------------------------------------------------\n",
      "example_index : 0\n",
      "----------------------------------------------------------------------\n",
      "doc_span_index : 0\n",
      "----------------------------------------------------------------------\n",
      "tokens :\n",
      "['[CLS]', 'to', 'whom', 'did', 'the', 'virgin', 'mary', 'allegedly', 'appear', 'in', '1858', 'in', 'lou', '##rdes', 'france', '?', '[SEP]', 'architectural', '##ly', ',', 'the', 'school', 'has', 'a', 'catholic', 'character', '.', 'atop', 'the', 'main', 'building', \"'\", 's', 'gold', 'dome', 'is', 'a', 'golden', 'statue', 'of', 'the', 'virgin', 'mary', '.', 'immediately', 'in', 'front', 'of', 'the', 'main', 'building', 'and', 'facing', 'it', ',', 'is', 'a', 'copper', 'statue', 'of', 'christ', 'with', 'arms', 'up', '##rai', '##sed', 'with', 'the', 'legend', '\"', 've', '##ni', '##te', 'ad', 'me', 'om', '##nes', '\"', '.', 'next', 'to', 'the', 'main', 'building', 'is', 'the', 'basilica', 'of', 'the', 'sacred', 'heart', '.', 'immediately', 'behind', 'the', 'basilica', 'is', 'the', 'gr', '##otto', ',', 'a', 'marian', 'place', 'of', 'prayer', 'and', 'reflection', '.', 'it', 'is', 'a', 'replica', 'of', 'the', 'gr', '##otto', 'at', 'lou', '##rdes', ',', 'france', 'where', 'the', 'virgin', 'mary', 'reputed', '##ly', 'appeared', 'to', 'saint', 'bern', '##ade', '##tte', 'so', '##ub', '##iro', '##us', 'in', '1858', '.', 'at', 'the', 'end', 'of', 'the', 'main', 'drive', '(', 'and', 'in', 'a', 'direct', 'line', 'that', 'connects', 'through', '3', 'statues', 'and', 'the', 'gold', 'dome', ')', ',', 'is', 'a', 'simple', ',', 'modern', 'stone', 'statue', 'of', 'mary', '.', '[SEP]']\n",
      "----------------------------------------------------------------------\n",
      "token_to_orig_map :\n",
      "{17: 0, 18: 0, 19: 0, 20: 1, 21: 2, 22: 3, 23: 4, 24: 5, 25: 6, 26: 6, 27: 7, 28: 8, 29: 9, 30: 10, 31: 10, 32: 10, 33: 11, 34: 12, 35: 13, 36: 14, 37: 15, 38: 16, 39: 17, 40: 18, 41: 19, 42: 20, 43: 20, 44: 21, 45: 22, 46: 23, 47: 24, 48: 25, 49: 26, 50: 27, 51: 28, 52: 29, 53: 30, 54: 30, 55: 31, 56: 32, 57: 33, 58: 34, 59: 35, 60: 36, 61: 37, 62: 38, 63: 39, 64: 39, 65: 39, 66: 40, 67: 41, 68: 42, 69: 43, 70: 43, 71: 43, 72: 43, 73: 44, 74: 45, 75: 46, 76: 46, 77: 46, 78: 46, 79: 47, 80: 48, 81: 49, 82: 50, 83: 51, 84: 52, 85: 53, 86: 54, 87: 55, 88: 56, 89: 57, 90: 58, 91: 58, 92: 59, 93: 60, 94: 61, 95: 62, 96: 63, 97: 64, 98: 65, 99: 65, 100: 65, 101: 66, 102: 67, 103: 68, 104: 69, 105: 70, 106: 71, 107: 72, 108: 72, 109: 73, 110: 74, 111: 75, 112: 76, 113: 77, 114: 78, 115: 79, 116: 79, 117: 80, 118: 81, 119: 81, 120: 81, 121: 82, 122: 83, 123: 84, 124: 85, 125: 86, 126: 87, 127: 87, 128: 88, 129: 89, 130: 90, 131: 91, 132: 91, 133: 91, 134: 92, 135: 92, 136: 92, 137: 92, 138: 93, 139: 94, 140: 94, 141: 95, 142: 96, 143: 97, 144: 98, 145: 99, 146: 100, 147: 101, 148: 102, 149: 102, 150: 103, 151: 104, 152: 105, 153: 106, 154: 107, 155: 108, 156: 109, 157: 110, 158: 111, 159: 112, 160: 113, 161: 114, 162: 115, 163: 115, 164: 115, 165: 116, 166: 117, 167: 118, 168: 118, 169: 119, 170: 120, 171: 121, 172: 122, 173: 123, 174: 123}\n",
      "----------------------------------------------------------------------\n",
      "token_is_max_context :\n",
      "{17: True, 18: True, 19: True, 20: True, 21: True, 22: True, 23: True, 24: True, 25: True, 26: True, 27: True, 28: True, 29: True, 30: True, 31: True, 32: True, 33: True, 34: True, 35: True, 36: True, 37: True, 38: True, 39: True, 40: True, 41: True, 42: True, 43: True, 44: True, 45: True, 46: True, 47: True, 48: True, 49: True, 50: True, 51: True, 52: True, 53: True, 54: True, 55: True, 56: True, 57: True, 58: True, 59: True, 60: True, 61: True, 62: True, 63: True, 64: True, 65: True, 66: True, 67: True, 68: True, 69: True, 70: True, 71: True, 72: True, 73: True, 74: True, 75: True, 76: True, 77: True, 78: True, 79: True, 80: True, 81: True, 82: True, 83: True, 84: True, 85: True, 86: True, 87: True, 88: True, 89: True, 90: True, 91: True, 92: True, 93: True, 94: True, 95: True, 96: True, 97: True, 98: True, 99: True, 100: True, 101: True, 102: True, 103: True, 104: True, 105: True, 106: True, 107: True, 108: True, 109: True, 110: True, 111: True, 112: True, 113: True, 114: True, 115: True, 116: True, 117: True, 118: True, 119: True, 120: True, 121: True, 122: True, 123: True, 124: True, 125: True, 126: True, 127: True, 128: True, 129: True, 130: True, 131: True, 132: True, 133: True, 134: True, 135: True, 136: True, 137: True, 138: True, 139: True, 140: True, 141: True, 142: True, 143: True, 144: True, 145: True, 146: True, 147: True, 148: True, 149: True, 150: True, 151: True, 152: True, 153: True, 154: True, 155: True, 156: True, 157: True, 158: True, 159: True, 160: True, 161: True, 162: True, 163: True, 164: True, 165: True, 166: True, 167: True, 168: True, 169: True, 170: True, 171: True, 172: True, 173: True, 174: True}\n",
      "----------------------------------------------------------------------\n",
      "input_ids :\n",
      "[101, 2000, 3183, 2106, 1996, 6261, 2984, 9382, 3711, 1999, 8517, 1999, 10223, 26371, 2605, 1029, 102, 6549, 2135, 1010, 1996, 2082, 2038, 1037, 3234, 2839, 1012, 10234, 1996, 2364, 2311, 1005, 1055, 2751, 8514, 2003, 1037, 3585, 6231, 1997, 1996, 6261, 2984, 1012, 3202, 1999, 2392, 1997, 1996, 2364, 2311, 1998, 5307, 2009, 1010, 2003, 1037, 6967, 6231, 1997, 4828, 2007, 2608, 2039, 14995, 6924, 2007, 1996, 5722, 1000, 2310, 3490, 2618, 4748, 2033, 18168, 5267, 1000, 1012, 2279, 2000, 1996, 2364, 2311, 2003, 1996, 13546, 1997, 1996, 6730, 2540, 1012, 3202, 2369, 1996, 13546, 2003, 1996, 24665, 23052, 1010, 1037, 14042, 2173, 1997, 7083, 1998, 9185, 1012, 2009, 2003, 1037, 15059, 1997, 1996, 24665, 23052, 2012, 10223, 26371, 1010, 2605, 2073, 1996, 6261, 2984, 22353, 2135, 2596, 2000, 3002, 16595, 9648, 4674, 2061, 12083, 9711, 2271, 1999, 8517, 1012, 2012, 1996, 2203, 1997, 1996, 2364, 3298, 1006, 1998, 1999, 1037, 3622, 2240, 2008, 8539, 2083, 1017, 11342, 1998, 1996, 2751, 8514, 1007, 1010, 2003, 1037, 3722, 1010, 2715, 2962, 6231, 1997, 2984, 1012, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
      "----------------------------------------------------------------------\n",
      "segment_ids :\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
      "----------------------------------------------------------------------\n",
      "start_position :  130\n",
      "----------------------------------------------------------------------\n",
      "end_position : 137\n",
      "----------------------------------------------------------------------\n",
      "is_impossible : False\n"
     ]
    }
   ],
   "source": [
    "print(\"example to feature :\")\n",
    "print(type(train_features[0]))\n",
    "print(\"-\"*70)\n",
    "print(\"unique_id : \",train_features[0].unique_id)\n",
    "print(\"-\"*70)\n",
    "print(\"example_index :\",train_features[0].example_index)\n",
    "print(\"-\"*70)\n",
    "print(\"doc_span_index :\",train_features[0].doc_span_index)\n",
    "print(\"-\"*70)\n",
    "print(\"tokens :\")\n",
    "print(train_features[0].tokens)\n",
    "print(\"-\"*70)\n",
    "print(\"token_to_orig_map :\")\n",
    "print(train_features[0].token_to_orig_map)\n",
    "print(\"-\"*70)\n",
    "print(\"token_is_max_context :\")\n",
    "print(train_features[0].token_is_max_context)\n",
    "print(\"-\"*70)\n",
    "print(\"input_ids :\")\n",
    "print(train_features[0].input_ids)\n",
    "print(\"-\"*70)\n",
    "print(\"segment_ids :\")\n",
    "print(train_features[0].segment_ids)\n",
    "print(\"-\"*70)\n",
    "print(\"start_position : \",train_features[0].start_position)\n",
    "print(\"-\"*70)\n",
    "print(\"end_position :\",train_features[0].end_position)\n",
    "print(\"-\"*70)\n",
    "print(\"is_impossible :\",train_features[0].is_impossible)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "n300ueTn0ghL",
    "outputId": "316328ac-8680-4f60-b09b-bfa796508835"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "87599\n",
      "97077\n"
     ]
    }
   ],
   "source": [
    "print(len(train_examples))\n",
    "print(len(train_features))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "H5m34tGhux_B"
   },
   "outputs": [],
   "source": [
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bSgVGyZVvkZF"
   },
   "source": [
    "### Loss Function :\n",
    "\n",
    "* It uses **categotical crossentropy** loss function internally.\n",
    "* Calcaulates loss seperately for start_token and end_token\n",
    "* total loss is average of start and end loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 170
    },
    "colab_type": "code",
    "id": "qs0Q9Dxffxvz",
    "outputId": "4be81d97-eea5-4750-ecb3-6c078b49d11d"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I0827 06:24:27.257017 140491252946816 <ipython-input-41-9544e7b43547>:6]   Num steps = 10949\n",
      "W0827 06:24:27.258475 140491252946816 deprecation_wrapper.py:119] From bert_repo/run_squad.py:691: The name tf.FixedLenFeature is deprecated. Please use tf.io.FixedLenFeature instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***** Started training at 2019-08-27 06:24:27.255979 *****\n",
      "  Num examples = 87599\n",
      "  Batch size = 16\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I0827 06:24:28.046493 140491252946816 estimator.py:360] Skipping training since max_steps has already saved.\n",
      "I0827 06:24:28.047625 140491252946816 error_handling.py:96] training_loop marked as finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***** Finished training at 2019-08-27 06:24:28.050430 *****\n"
     ]
    }
   ],
   "source": [
    "print('***** Started training at {} *****'.format(datetime.datetime.now()))\n",
    "print('  Num examples = {}'.format(len(train_examples)))\n",
    "print('  Batch size = {}'.format(TRAIN_BATCH_SIZE))\n",
    "\n",
    "\n",
    "tf.logging.info(\"  Num steps = %d\", num_train_steps)\n",
    "train_input_fn = run_squad.input_fn_builder(\n",
    "    input_file=train_writer.filename,\n",
    "    seq_length=MAX_SEQ_LENGTH,\n",
    "    is_training=True,\n",
    "    drop_remainder=True)\n",
    "\n",
    "estimator.train(input_fn=train_input_fn, max_steps=num_train_steps)\n",
    "print('***** Finished training at {} *****'.format(datetime.datetime.now()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dfzCy_Xvs_c-"
   },
   "source": [
    "## Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "f6aZC203wMxq"
   },
   "source": [
    "The below steps are used while prediciton:\n",
    "\n",
    "* A Dense layer followed by softmax layer is applied on the final output. \n",
    "* The probability of word i being the start of the answer span is computed as a dot product between Ti and S followed by a softmax over all of the words in the paragraph.\n",
    "* The end and start tokens are chosen which maximises probabilities."
   ]
  },
  {
   "attachments": {
    "prediction.jpg": {
     "image/jpeg": "/9j/4AAQSkZJRgABAQEAeAB4AAD/4RFORXhpZgAATU0AKgAAAAgABAE7AAIAAAAsAAAISodpAAQAAAABAAAIdpydAAEAAABYAAAQ7uocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFNoaW5kZSAoRVhUKSwgUmFtYW4gKERJIFNXIE1PTSBERU4gUiZEIEVERCkAAAWQAwACAAAAFAAAEMSQBAACAAAAFAAAENiSkQACAAAAAzg4AACSkgACAAAAAzg4AADqHAAHAAAIDAAACLgAAAAAHOoAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMDE5OjA4OjA1IDAwOjM3OjIxADIwMTk6MDg6MDUgMDA6Mzc6MjEAAABTAGgAaQBuAGQAZQAgACgARQBYAFQAKQAsACAAUgBhAG0AYQBuACAAKABEAEkAIABTAFcAIABNAE8ATQAgAEQARQBOACAAUgAmAEQAIABFAEQARAApAAAA/+ELQmh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2luPSfvu78nIGlkPSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4NCjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iPjxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iLz48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyI+PHhtcDpDcmVhdGVEYXRlPjIwMTktMDgtMDVUMDA6Mzc6MjEuODgzPC94bXA6Q3JlYXRlRGF0ZT48L3JkZjpEZXNjcmlwdGlvbj48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyI+PGRjOmNyZWF0b3I+PHJkZjpTZXEgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj48cmRmOmxpPlNoaW5kZSAoRVhUKSwgUmFtYW4gKERJIFNXIE1PTSBERU4gUiZhbXA7RCBFREQpPC9yZGY6bGk+PC9yZGY6U2VxPg0KCQkJPC9kYzpjcmVhdG9yPjwvcmRmOkRlc2NyaXB0aW9uPjwvcmRmOlJERj48L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgPD94cGFja2V0IGVuZD0ndyc/Pv/bAEMABwUFBgUEBwYFBggHBwgKEQsKCQkKFQ8QDBEYFRoZGBUYFxseJyEbHSUdFxgiLiIlKCkrLCsaIC8zLyoyJyorKv/bAEMBBwgICgkKFAsLFCocGBwqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKv/AABEIAksEaQMBIgACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APpGiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooqtBqVjc391Y217bzXdns+028cqtJBvGV3qDlcjkZ6igCzRRRQAUUUUAFVtQ1Kx0iwkvtVvLextIseZcXMqxxpkgDLMQBkkD6mrNeJftVf8kt03/sMxf8AomagD2i2uYLy1iubSaOe3mQSRSxOGSRSMhgRwQQcgipa/OKS2mhjheaGSJLhPMhd1IEibiu5Seo3KwyO6kdjXUWPw8vtStVuLDUtNniP8SSucHGcH5eDz0PNTKUY6yZlUq06SvN2R960V8Jf8Kt1n/n7sf8Avt//AImj/hVus/8AP3Y/99v/APE1Htqfc5/r+F/nR920V8Jf8Kt1n/n7sf8Avt//AImj/hVus/8AP3Y/99v/APE0e2p9w+v4X+dH3bRXwl/wq3Wf+fux/wC+3/8AiaP+FW6z/wA/dj/32/8A8TR7an3D6/hf50fdtFfCX/CrdZ/5+7H/AL7f/wCJo/4VbrP/AD92P/fb/wDxNHtqfcPr+F/nR920V8Jf8Kt1n/n7sf8Avt//AImj/hVus/8AP3Y/99v/APE0e2p9w+v4X+dH3bRXwl/wq3Wf+fux/wC+3/8AiaP+FW6z/wA/dj/32/8A8TR7an3D6/hf50fcmo6lY6TYyXuq3lvY2kWPMuLmVY40yQBlmIAySB9TUltcwXlrFc2k0dxbzIJIpYmDJIpGQykcEEcgivhcfC3WR/y92P8A32//AMTXL6ppN7o12bXUYGhlwGAOCCD3BHBqo1Iy0TNqWJo1XaEkz9FaK+N9B/Z31/xRpSaj4f8AE3hfULR8DzILuZtpKhtrDycqwDDKtgjPIFaX/DKnjf8A6Cvh/wD8CJ//AIzVm59bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKnjf/AKCvh/8A8CJ//jNAH1tRXyT/AMMqeN/+gr4f/wDAif8A+M0f8MqeN/8AoK+H/wDwIn/+M0AfW1FfJP8Awyp43/6Cvh//AMCJ/wD4zR/wyp43/wCgr4f/APAif/4zQB9bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKnjf/AKCvh/8A8CJ//jNAH1tRXyT/AMMqeN/+gr4f/wDAif8A+M0f8MqeN/8AoK+H/wDwIn/+M0AfW1FfJP8Awyp43/6Cvh//AMCJ/wD4zR/wyp43/wCgr4f/APAif/4zQB9bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKnjf/AKCvh/8A8CJ//jNAH1tRXyT/AMMqeN/+gr4f/wDAif8A+M0f8MqeN/8AoK+H/wDwIn/+M0AfW1FfJP8Awyp43/6Cvh//AMCJ/wD4zR/wyp43/wCgr4f/APAif/4zQB9bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKnjf/AKCvh/8A8CJ//jNAH1tRXyT/AMMqeN/+gr4f/wDAif8A+M0f8MqeN/8AoK+H/wDwIn/+M0AfW1FfJP8Awyp43/6Cvh//AMCJ/wD4zR/wyp43/wCgr4f/APAif/4zQB9bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKnjf/AKCvh/8A8CJ//jNAH1tRXyT/AMMqeN/+gr4f/wDAif8A+M0f8MqeN/8AoK+H/wDwIn/+M0AfW1FfJP8Awyp43/6Cvh//AMCJ/wD4zR/wyp43/wCgr4f/APAif/4zQB9bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKnjf/AKCvh/8A8CJ//jNAH1tRXyT/AMMqeN/+gr4f/wDAif8A+M0f8MqeN/8AoK+H/wDwIn/+M0AfW1FfJP8Awyp43/6Cvh//AMCJ/wD4zR/wyp43/wCgr4f/APAif/4zQB9bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKnjf/AKCvh/8A8CJ//jNAH1tRXyT/AMMqeN/+gr4f/wDAif8A+M0f8MqeN/8AoK+H/wDwIn/+M0AfW1FfJP8Awyp43/6Cvh//AMCJ/wD4zR/wyp43/wCgr4f/APAif/4zQB9bUV8k/wDDKnjf/oK+H/8AwIn/APjNH/DKvjcf8xXw/wD+BE3/AMZoA+tqK+BfiB4A1X4ca/BpGuT2c9xPbLdK1m7sgQsygEsqnOUPb0r76oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCjreqwaFoGoavdpI9vp9rLdSrEAXKopYgAkAnA4yRXxV8H/ABTe6T8atFv5Zbi6l1K9+y3Za4YNP9oOws5534dlkwepUcg8j3/9p3Xv7M+FSaZHJb+Zq17HC8UjfvDEn71mQZ7OkYJwQA+OpBr5m1rwbd6N4M0LxBL5xTVvN3RvblBBtPyZbPO9csOBwOM9aaVxNpbn36KK5/wJ4lTxh4D0fXlaNnvbZWn8pGVFmHyyqobnAdWA69Op610FIYUUUUAFeJftVf8AJLNN/wCwzF/6Imr22vEv2q/+SWab/wBhmL/0RPQBnfC/wf4Y+KXwA0nQ9ajkFxpU822eBlWeAvM75QnPyMDtIYYJU8ZUEeQeI/DviP4K+Mja3o+02NxkwTqCsV7ED+O11yMjkqT3Ugt7j+zHJbRfDdt99+/mvGjW1aUYGAzBlTrlgHye4j/2TXqXiRPDupaVeaN4olsXtJ4N1xb3Uyp+7LBQ/JBX5sYYYw2MHOKzupR943xGGUpezUbpqL+9Jv8AE+bvD/iC08Q6eLm0O11wJYSfmjb+o9D3/AgalcP48+GerfDW8n1rwvq8ep6Ikif6RazB5raOTa0QuFHG1ugYZVsA4Xcq1q+GPGVl4gijhkZYNQwd0B6NjqVPcd8dRg+ma4K1Bx96OqPi8wyueHblBafkdHRRRXIeIFFFFABRRRQAUUUUAFFFFABWbrmgWPiCzFvfo3ynKSJgOnrg89e4x+uK0qKpNp3RdOpKnJSg7M858OeIvEfwV8Zi7sz9psbjAngYkRXsQPQ9drrk4PJUnurEN9X/AA5+IukfEjw4NS0pvJuYsJeWLtmS2c9j/eU4O1sYIB6EMB4hd2lvf2clreRLLDKu1kbv/nrmvNbvSvEXw51T+3PC+p3FvGrhRPA5DKu5WCSr0ZSwHBypwMjkCvSo4hT0lufW4HMo17QqaS/M+56K8x+Ffxq0X4hWttYXcken+JCjebYkELLtAJeJjwQQc7Cdww3ULuPporqPYFooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD5J/ar/AOSqab/2Bov/AEfPX1tXyT+1X/yVTTf+wNF/6Pnr62oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACg0VFdXMFnaS3V3NHb28KNJLLK4VY1AyWJPAAAySaAPlH9o/WLvxP8AFyx8LaeJJDp0cdvHC6ooa4n2uSrZ6FTCPmIAKngdT2XxN8LRN8GptNs4XuDo0EUls0kgDKsICs56Anyt/HfPAzivNfh7cT+P/j3c+IrxFZfMn1FobmQymNfuxIrEc7C8YXgYCcYwBX0TPBFc28kFzGk0MqlJI5FDK6kYIIPUHpiuujC8WebiqvLUjboch+y14mfU/AeoaDO0jvo90GiyihFhmywUEck71lJz/eGD2HuNfIXwOvYPBP7QFxot1JHIlz9p0kXMjiIBlcMpwc5LNEEC56uOT0P14K5Xoz0VqhaKKKQwrxL9qv8A5JZpv/YZi/8ARE9e214l+1X/AMks03/sMxf+iJ6APF/CH/Iq2f8AwP8A9DatqsXwh/yKtn/wP/0Nq2q8Cr/El6s/aMt/3Gj/AIY/kj1v4J2C3eneIEvbUTWVyIoHWaPdHKMSb0OeDwwyPRhnrXn3xc+ANxoE0Wv/AA0tLqW1UqJtNgLyzW7cASRdXdScZHLKeRlc7Os+GfjDTvDFlcJfSX8j3FwqC3SSEQDcBtfDsrA/KwZs7QNu7tXtB1bTf7M/tH+0LX7D/wA/Xnr5X3tv38468devFerhZR9kkfnPEOHq/X51HHSTSXnokfH/AIQ8ef2rMthrGyK6bCxSgYWU+h9GJ544PTjjPbVr/En4NaL8RLi/8S/DrUrQasoZrqxiZfLu5dxG7OR5bttf5iNrnByMs58h8M+NrjSrqbSPFfnxvC7IZJ0bzIXBO5HB+brkc8g8dOmVbDp+/A/PMyyiUZOVNWfVHo9FNjkSWNZInV0dQyspyGHYg96dXCfMtNaMKKKKQgooooAKKKKACiiigApskaSxNHKiujgqysMhh3BFOop+Y7tannHibwTcaVdQ6t4T8+N4XVxHAzebC4I2uhHzdcH1B56dPbPhF+0BD4qu7Tw54wSOz1d0WOC+DARXsuSNpXAEbkbcAcM2QNpKqeari/FvgKPVpJdQ0orDdkFnhxhZm9c/wk8+xOM45Nd1HEfZmfSYDNNqdd/P/M+yxRXy98I/j9caBNL4f+Jd5dS2qsxh1K4DyzQNyTHL1d1Jzg8sp4OVxs+nLa5gvLWK5tJo57eZFkilicMkikZDKRwQQcgiu8+jJaKKKACiiigAooooAKKM0UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUZoAKKKKAPkn9qv/AJKppv8A2Bov/R89fW1fJP7Vf/JVNN/7A0X/AKPnr62oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvO/jt4lTw18INYYNGLjUk/s6BJEZg5lBDjjoRGJGBJxlR16H0M18zftYa95mq+H/D0T3C+TDJezpnET722RnGeWXy5eo4D8Hk0AH7Pej/AGXwnqOqyJMj310I13jCNHGvDLxz8zuCcn7uOCDXrdY/hLQl8M+EdM0hVQNawKsvlsWVpTzIwJ5wWLHt16DpWxXpU1yxSPn60ueo2fO/xrsrvwx8TtP8T6Y7xS3IjuYZm2OEuICo4UjoAIj8wIJJ+g+vdN1C11fSrXUtPl860vIUuIJNpXejqGU4IBGQRwRmvnr496Cuo+BI9UVU87S5wxZmYHy5CEZQBwSW8s89lPPY9x+zj4gn1z4P28N15jPpV1JYiWSUuZFAWRev3QqyBAvOAg+g4q0bTPXw0+ekj1cUUUVkdIV4l+1X/wAks03/ALDMX/oievba8S/ar/5JZpv/AGGYv/RE9AHi/hD/AJFWz/4H/wChtW1WL4Q/5FWz/wCB/wDobVtV4FX+JL1Z+0Zb/uNH/DH8kFFFFZneer/A63cXuqXDQ/I0aokxt2OSDllEv3V6qSvU/Kf4TW38Vfg5pHxD0uWe0it9P8QJ88N+se3ziFACTEDLLhQAeSuARkZVue+ExgtdMv8AUdV1HyNPt7iIBVv5Y/JkJUBniXClHyBuY4+QgjGSPSYPGuhvpMl/d6lZW8SzTxL/AKSrFxE5GVA5YldrYAJw69cgn2MNJRppM/Ls+o1auPnOEW9UtF1tt92/+Vj4+jvvEvwx1kaB4s06SBAFlMMjBiqNn5o3UlSM56EjKkcHNei2l3Bf2kd1ZyrLBIu5HXoR/T0xXrXjTw94S+Lnh+80y4vbcT6fMsdrqMUiMYJZFXaVIb5kYkIVONxUgYZVYfLOqWeo/CnxnJaQX9rq1i/Mc9rKGiuos8HgnY47g8qf7ykFirRjU1jufDZhk8qqc4xtJb6d9r9j1Kis3Q9fsfEFmZ9PdvkO14nADp6ZHoex/wADWlXnSTi7M+NnTlTlyyVmFFFFSQFFFFABRRRQAUUUUAFFFFAHOeJ/B1lr8Mk0arBqG0bZ+cNjoGHcds9Rx1AxVP4dfF3xH8J7qPQtdtJLrQ/P3vbSA+bApJDNA2QMFvmwcqSDgqWLV19ZfiDw/aeIdPNvdDbIuTFMB80bevuD3Hf64I66OIcdJbHtYDMpUX7OprH8j6d0XWdO8Q6Nbatot3HeWN0m+GaM8MOnfkEHIIOCCCCARV6viHw74i8RfBXxoLqyP2mxuMCe3YlYr2IHp32uueDyVJ7qSG+tfAXxE0H4i6NJqHh6aQGF9lxa3ChZoDzt3KCRhgMggkHkdQQPSTTV0fWQnGcVKLumdTRRRTKCmswVcscAck+lOrz345395p3wa12XTg3mPEkTsv8ADG7qr/8AjpI/Gpk7IaV3Ykk+N/w5jnu4W8U2260BMmIpCDg4+QhcSdf4M+vatjUviD4W0e4sYdU1eKze/tTd2/nI6hogMliSMLx2bBJ4AzXgvjW+8Mar4A8BeAfCUtrfTT3Vq072wVvKZl2tvI+7IzMSR1+U5xXYvplp4v8A2p5YruBbmy8M6XGVjcZRZshl49f3mfqo9Ku2tvX8ET0uel+G/iB4W8XWF3e+H9Zgubey5uXYNF5IwTuYOAQMA89ODzxVHR/iz4H1/ULmx0jX4bi4to3lkQRyLlEBLFSVAcAAn5SeK8j8LnQtVHxPvfEurR6RYa/qx0uC7Y7VVh5jA56dME5IHXkZrY+EWp3lxrmqeBbi70vxFpWh2JWx1mwiAEavhfL3DjJBOcZ5Vss1T0uu1x7PXuenJ8RvCsngp/Fq6uv9hq203RhkHO7ZjYV3Z3cYxUuo+O/DmlWmj3N/qQii1tkTTyIZGM5cArhQpIzuHJAxnmvljw3HfeMPh3ceEIRLHZeHYb7VrxwD+8kCEQx/XduOPr6V3nwx874ieJfD2pLFI+k+CdHihi3pgTXpjAIH0wOn91fWnpv/AFYLNHr3iP4q+CfCWqDTdf1+C2vMAtCkbysmem7Yp28EH5scc1e1Lx54Y0iw0y+1DWIIrTVWC2c43MkvGc7gCFGO5wB3NfN3gdLbVvC2u3XiL4m2fh1dWu5TrGmNZwtdTgnnbIx8znJ4UHvxya7PxN4X0u7+K/w88AWcTz6PpFm93NDMc715YbwRg7jHyMfxEYFFtk+oO2p7R4a8U6P4v0ttS8O3f2yzErRed5ToCy9cbgMjnqOK1J54raCSe4lSKGJS8kjsFVFAySSegFOVQqgKAABgADpXLfEeTQ5PBN3pnibV00e01UfYlu5DgJIwJXJ6AfKTyQMDqKUttAXmVdL+LvgXWby7ttM8QwTTWcMk0w8uRRsQEsyllAYAAn5SeK5XwD8crPxh8RNU0OWa2S0aUJovlWs3m3QAYuzHkKAFzyF4NY/wl8R3ljq+r+Fp7nTPEel+GLAy2Gs2EI+QED93leCWGemTlTktVD4Ra2lr8EPFuo6Zf283iKY3moPbRyAzREJhWKZzjIyD709rvyDfTzPUL/4weAtL1y40i+8S2sV5b7vNXa5VCoyV3hdu4YxtznPGM8Vdm+I/hO20bStVudXSGx1dyllNLDIokIznOVyo46tgV883viDwvpf7L1toOlT2t7rerur3UUQV5Y387JeQdVwAEXPJyMetdd4h8PQ6t8Tfhr4Eu4hPaaPpguLyBuUbag4YdCCYsf8AAvemlrbz/wCCxX6m34//AGhNC0fwvHdeCb621PUppgsUVzazCPYCQ787MjIwMHk+uDXp3hbxJp/izw7b6vo9yLq1mBAmELxhmU4bCuAcZBFeUfGq/tD8Svh9pOp3MNjpsV6b2eachI1CFdoLHAA4I9twr2mKWO5tkmtpVkilQMksbBgwIyCD0IxzUp+7cb3SMrxL4w0DwhYi68RanBZI3+rRjmSU+iIMsx57A1N4e1l9f0hNRbTb3TUlY+XBfRiOXaDgMVydueoB5xXkFh4Q1/4YeJ7rxBqWg/8ACeRTvubVoSz6lbD0ETsQw5wNhB65IGBXtEd4bnSkvbaJ/wB7CJY45FKtyMgEdj7UXtG4dbHOa58UvBfhvXk0XW9ftrW/bbmIqzBM9N7AFU4IPzEcc9KevxN8Iv4VPiRdXB0gXP2X7T9nlwZM4wF27jz3Ax714L4V8XeH9J+CfjC+1a4trjxVrtxcxzWrgNcMWGBlTzsXLPk8Zz34qxrGj7vhX8K/BBDK+tXq3U6KcExs24k/QTZ/Cml+n4g+/r+B7npXxM8Ha34lbw/pOvW11qa5/coGw+BkhXxtYgZOFJ6H0qHUfiv4I0nxINBv/ENtFqO8RmIK7KjH+FnAKqfYkYrzzWk02z/aS0KCJIbLS/C2gSXMgjTCwoFk7DnADKcVhaJqMPhH4l2Wk+Edd0nxdoHi7UDNc2ARZZ7Ykg7nYZ+6MH5v7p+UHmhatef+YPS57rpvjDQtW1vVNI0+/WW/0kgXsRjdfJznHzEAHoehNU7L4jeFdQ8J3viWz1ZZNHsXZLi68mQBGGMjaV3H7w6A5zxXg/iu91DTfjd4z8NaIri+8VJbWcL84jDqhkc+wUv9PwrK0nTpryTUPg5o7TgT+JpZLubZ/qrKIKNxPqSoIz3AHelH3kn/AF5jej/rsfRep/Evwho3h2x1zVNbhtrDUEElo7xvvmU91j27yORn5eMjPWnWPxF8J6l4Uu/EljrMU2k2YP2idY3zFjsU27weRxjmvE9ZEh/aF1SJvGFj4K/sawhttMuL21imTydikqnmsFU/MeRzyR60vjPS9F8N/Am8TwtrE2uXPirVkim1Bht+1ShyWCgAALuRvUcnk8U+l11/zF1sz27w/wCP/DPinVJtO8Paol9dQQrPKscUmERsYyxUKDz93ORzkcGujrK8MaBZ+GPDNho+nwpDBaQrGAgxk4+Zj6knJJ7k1pTs6W8jRLudVJVfU46UStEUbs5TxH8VfBPhLVBp2v6/BbXmAWhSN5WTPI3bFO3gg/Njjmr+oeO/DOl2el3d9q8EdtqzhLKcZZJSRnO4AhRjucAetfNvgZLbVvCuu3fiL4nWfh1dWu5Tq+mNZwm6nGedrsfMwcnhQQOfU12fifwrpV78Vfh78PrWJ59H0mzku5oZTnevJBfpksY+eP4jwKLPTzG+p6z4a+IvhPxhqNzY+G9ahvrq1G6WNVZTtzjcu4Dcuccrkcj1FYviL4yeCtJk1LTR4htv7VtYJWEIDlfMVSdnmAbN2RjG7OeOted3FzdN8YPibreiLsl0Tw+ba2MK4KyeWuCPcFG/IVy9z4i8K6P+y5FommS2t9rWq4kuoowryQv52TJL3XAAVSeeVx61L1j/AF1KWjPafgY+rXPwo06/1++u767vXlm827naV9pchRliTjCg4969ErE8GaUdD8EaNpbY32llFE+O7BACfzzW3Wkt9DOOqufJP7Vf/JVNN/7A0X/o+evravkn9qv/AJKppv8A2Bov/R89fW1SUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFACGviXxJr2leI/2hL7V9fvLRNJXVCGniiM8M0MHyR/KCdwdY1BIyPnJxjivto14vc/st+Bp7qWWK91y2R3LLDFcxlIgTnapaMtgdBkk+pNNaMT1Vi34d8c+HPFdxNBoGqJdTQKHePy3jYKTjIDgZGepHTIz1Fb9fOX7PP8AyP8Aff8AYMk/9GxV9G16FOTlG54WIpqlPlicJ4u+IHg37FrHhzUPECWtzLBLaSsltJMImZCp+6uCRnkZ6gg4Oa4j9lvxKmm+PdQ0GZo0TWLYNFlGLtNDlgoI4A2NKTn+6MHseY0bwrY+Nv2i73w9qstxDaXmp33mPbMqyDYJXGCwI6qO3SvorwV8BfCfgXxRDr2mXGqXd5bo6wi8nQrGWG0sAiLk7Sw5JHzHjOCOKpNyep69CkqcdOp6cKKQUtZm4V4l+1X/AMks03/sMxf+iJ69trxL9qv/AJJZpv8A2GYv/RE9AHi/hD/kVbP/AIH/AOhtW1WL4Q/5FWz/AOB/+htW1XgVf4kvVn7Rlv8AuNH/AAx/JBRRRWZ3hRRRQAV1fgiz8L6jLc2njcxNp8jIEimPyPIySICcNlcK7EOF+U4O9Oj8pRVQnySUkcuLw0cVQlQk7KRy/ibwxe+BfE2q3ng7UH1DRrKQIt8u0kI/GHX+JQ2F3gbCdh4LKK6vwv4utPENqqyPHBfjh4C2NxxnKeo4PHUd+xPpvwpTS7Pw/rupa0tnNazPBYyxyhWKRyNtbeG4ETb1zk4OxuOK87+KfwQi8O6aPGHw2upb7SIi0txFHMJWtQGJ8yN15aNehzll25JI3FfVUVXgnLRn4zxBktGNeVOF7Rsubzsm1+JsUVxfhPx7Hq0kVhqgWG7KhUlzhZm9Mfwk8exOenArtK4ZwlB2Z+cYjD1MPPlmgooorM5wooooAKKKKACiiigAooooAr3thaalbG3v7eOeI/wuucHGMj0PJ5HNedPaeJvhjrza74UvpoI1Uxi5QK2Fb+CRCCCMgdQRkKeDjHptNkjSWJo5UV0cFWVhkMD1BHet6VaVN+R6GDx1TCy01j2PUPhV8Y9I+ImlxQXctvp/iBPkm09pMecQpJeEE5ZcKxI5K4IORhm9Ir4e8TeCptCkTWfDUs8f2dxMQjkSW7A5V0Yc4HHuMZyeSPcPhF+0BD4qu7Tw54wSOz1d0WOC+DBYr2TJG0rgCNyNuAOGbIG0lVPqQnGauj7GhXp14c8Ge5VFcW8N1bvBdRJNDIpV45FDK6nqCDwR7VJRVm5kW/hLw5aJbJa+H9LhWzlM1ssdnGogkOMumB8rHA5HPFWrbRtMs9Qub+0060gvLvH2i4igVZJsdN7AZb8avUUAZSeGNBTS5tNj0TTlsLhzJNaC0QRSscZZkxgngckdqn0zRtM0W0+y6Np1pp9vuLeVaQLEmfXaoAzV6koAzLPw1oenR3cen6Np9ql7/wAfSwWqILjr9/A+bqeuepqfTNI03RbP7Jo2nWun224t5NrCsSZPU7VAGauUtAGM3hDw2+rf2o3h/S21Df5n2s2UZl3f3t+M5981b/sfTf7X/tX+zrT+0vL8r7Z5C+ds/u78bse2cVeopAeczf8AC6TcSfZh4DEO4+WJDebgueM474ra0HTvFOqWF9afE218M3tvJsENvp8MskbDkt5gmyDztxgetdZRTAo6Zo2maLaG10bTrTT7fO7ybSBYkz64UAZqLTvDuiaNNcS6Ro9hYSXPM72tqkRl6n5ioG7qevqa06KAMRPBnheO2e3j8N6QkEkomeJbGIK8g6ORt5YZOD15q7/Y+m/2x/a39nWv9o+X5X2zyF87Z/d343Y9s4rP8ZeMdK8DeHZNY1tpPJRljSKFQ0kzt0RASMnqevQE1r2c5urKG4aGWAyxq5ilADx5GdrYJGR3wTQBV1bw/o2vRxx65pNjqSREtGt5bJMEJ7gMDir6oEUKoCqBgADpTs0UAIaOKranqEGk6VdaheMVt7SF5pSOyqCT+grlbL4p+G7n4fReM797nStImkKI15DmQncV+7GWJyQemeKVwNtvCPht5Lx38P6Wz3wxdsbKPNxzn5zj5uRnnNWH0HR5LqzuX0qyaewXZaSm3QtbLjGIzjKjHYYq3bzxXVrHcW7b4pUDowH3lIyDXPaT460zWvHGr+F7KC7+16QiNczMiiElgCFU7sk89wOhp9bB0ubK6PpkeqTanHp1qt/PGIpbsQKJZE4+VnxkjgcE9hUGmeGNB0W6kudG0PTbCeUYkltbSOJnHXkqATVHxP4203wlqGi2uqQ3JOs3Ys4JYUVkjkOMbySCAc9ge9dEKF5AZ50DSG1pdYbSrFtTVdq3xt088DGMCTG7GCR1pbTQdIsNSuNQsdKsra9us+fcw26JJLzn5mAy3PPNaFFAGTq3hfQNeljl1zQ9O1KSMbUe8tI5ig9AWBxUtzoGj3sFrDeaTY3EVm4e2SW2RlgYdCgI+Uj1GK0aSgDjPEf/AAs3+2n/AOEQHhP+zNq7P7U+0+cWx82fL+XGelN8PD4onW4f+EsPhEaXhvN/swXJnJwdu3edo5xnPau1ooWgbmO3hHw2+rf2o/h7S21Avv8AtZsozNu/vb8Zz75q3/Y+mf2v/av9nWv9o+X5X2zyF87Z/d343Y9s4q92ooApWmj6bYXF1cWOnWttPetvuZIYVRp255cgZY8nk+tUI/BnheK2kt4vDekpDLIJZI1sYgruOjEbcEjsetblFIBAMdBiloopgfJP7Vf/ACVTTf8AsDRf+j56+tq+Sf2q/wDkqmm/9gaL/wBHz19bUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB8Z/s8/8j/ff9gyT/wBGxV9G185fs8/8j/ff9gyT/wBGxV9G13UPgPGxn8U8B+Gv/J3H/cT1L/0XPX17XyF8Nf8Ak7j/ALiepf8Aouevr2uKW568fhQUUUUigrxL9qv/AJJZpv8A2GYv/RE9e214l+1X/wAks03/ALDMX/oiegDxfwh/yKtn/wAD/wDQ2rarF8If8irZ/wDA/wD0Nq2q8Cr/ABJerP2jLf8AcaP+GP5IKKKKzO8KKKKACiiigAr0D4VeIbPw9fXkuoSxRx3MkFvl7koV3FvmCY2sBwWZiNozgktg+f0VcJuElJHLjMLDF0JUJ7P/AIc7b4l/BvT/AIjSTeLPhlc2v25mJvrUkxx3T7A+5CRhZTuUMDhSWyxVg27ybwz42uNKuptJ8WGdHhdkMk6N5sLgnckgPzdQRzyDx06e+/B/xJouk6Pe2ep3y2dxJdBlNxNtjZShxgE4BGxstgdUGTwKXxp8LvDnxh8Nf2/pP2ax8STQRn7VFNvXzAmfJmC8HhgpbG8YXqBtPrxlGvBc25+P5zk6p1J0pRfImrN+aOGjkSWNZInV0dQyspyGB6EHvTq8vtNV8RfDnVf7D8UabcW8auWMFwhDKu5lLxN0ZSwPIypwcHkmvSrS7gv7OO6s5VlglXcjr3H9PTFcNWjKm/I/OcZgamFlrqu5NRRRWBwBRRRQAUUUUAFFFFABRRRQAVxHi/wENVma/wBH8uO6bJmiY4WU46j0Y/kc5yOSe3orSE5Qd0dOHxNTDz5oMq/CP4/XGgzS6B8S7y6ltVLGHUrhXlmt25Jjl6u6k5weWU8HK42fTlrcwXlrFc2k0c9vMiyRSxOGSRSMhlI4IIOQRXyV4n8HWWvwyTRqsGobRtnGcNjoGHcds9RgdQMVS+HXxd8R/Ce7j0LXLSS60Pz9720oPmwKSQzQNkDBb5sHKkg4Kli1epSqxqLTc+xwmNp4mN479j7Hoqjous6f4h0e21XRbuO8sbpN8M0Z4YfQ8gg5BBwQQQQCKvVsdwUUUUAFFFFABRRRQAUUUUAFIaWkoA8Z8XsfGP7Rnhzwy5DafoVudTuIzkhpf4cjocfu/wDvo16F8Qr/AFLSvh1rmoaJcC2vrSzeeGUor7So3dGBB4B6iuB8OxrH+1f4sMqYkk0mFomPddsIJH4j9K9V1nTl1fQr7TpMBLy3kgbPoylf61Lv7NWHpz6+R43rHxO8QXvwz8Dw+GtQRfFXiR44vOMKNgKdsrlSpUDdjt646Vot4k8aeOfHer6L4M1630PTPDgWG61CSyS4e7uMHI2twq5VhxgjGec4DfhB8F9R8E6odV8WX1rf3lrCbbTUtnd47aNmZnOWVeSWPbjLdc8Ni+FvjfSNT8V2vhvXdKtNF8QzSXDSyxyG7iZg2UXA2qDuxv8AmIHIGaqW7t5iRyy/EPxFrn7PXjPXvEl7FO1xc/2daRQQrHHGrbVbacbiMOfvZPy1paubvR9B+FfgO1jtXbUGikvori0iuEKKFZ+JFYA5ZyCADx1rQuPgtrT/AAf0DwZDd6er2+o/atVkMr7ZV3MSEOzJOGHUL0rq77wFqOofGvSvFk8tp/ZGlWDQW9uHbzRKQwLbdu3GG/vdhxT0v934L/MXT7/xMB/E3jHx98QNb0bwLrVv4f0nw8whnvHsVuGuZ+QUw/AUFWGRzxnnIAq/s8C41b/hLvFGpGJ73UtU8uSSEERnYM/JnnbmTj6VNb/C/wAb6NrHim38Oa7pdpoviGd7l5nSQ3kLNklEIG1c7iN/zEcEDNdj8K/BU/gH4f2eiX0lvLeI8ktxJbklGZmJ4JAJwu0dO1KOiv5f8OOXbzOQ+PM6tqPgOxT/AI+ZtfieM98KQD+rrXsIrxsq3xA/aPjkiXzdH8GQlWfqjXbjp9QfyMdeyCkvhB/F6C0UUUwCiiigAooooAKKKKACiiigAooooA+Sf2q/+Sqab/2Bov8A0fPX1tXyT+1X/wAlU03/ALA0X/o+evragAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPjP9nn/kf77/ALBkn/o2Kvo2vnL9nn/kf77/ALBkn/o2Kvo2u6h8B42M/ingPw1/5O4/7iepf+i56+va+Qvhr/ydx/3E9S/9Fz19e1xS3PXj8KCiiikUFeJftV/8ks03/sMxf+iJ69trxL9qv/klmm/9hmL/ANET0AeL+EP+RVs/+B/+htW1WL4Q/wCRVs/+B/8AobVtV4FX+JL1Z+0Zb/uNH/DH8kFFFFZneFFFFABRRRQAUUUUAFdd4F8RSeHftM8epfY1a4t/NjZEZbhBvyhG1nHJGWUYVd3VtityNFVGTg+ZHPiKEMRSdKezPdvEPhvQ/jX4LlttRg+x3lpIUgu4pI5zaz7EY7HRiJIzuAZcjOP4WAI+Z/Efh3xF8FfGZtL0fabG4yYJ1UiK9iB6jrtdc8jkqT3VgW9/+C+r6bYaRq6X2ofZnSRJWW4mVIVQ/KGUE8HcQGPT/Viu81WHwl400S6tNUfStY0+FS84aVJFgyrDfuBzGdu7DggjnBr2qc1Uprm6n5Fm2XqjiKlFRvBeTtql/mfPGh6/Y+ILM3Gnu3yna8TgB09MjPQ9j/ga0q4fxz8Nde+F2rT6z4auzf6BtjeK/hdHZIpSQgmQdiVwHxsY7cEMdo1/C/i608Q2qq7xwX44eAtjccZynqODx1HfsTxVqDhrHVH5/mGVzw7c4K8fxR0NFFFcp4oUUUUAFFFFABRRRQAUUUUAFZfiDw/aeIdONtdDa65MUwHzRn19x6jv9cGtSiqjJxd0aU6kqclKDszz3w94r8U/BfxTEbWeS60l3LSWTyEW92pwGIHISTCr8wGRgZ3KcN9aeCvH3h7x/pT3vhu987ydguLeRSktuzLkK6n8RuGVJVsE4NeC3thaalbG3v7eOeI/wuucHGMg9jyeRzXn0MPiT4VeJ08ReGZ2aCIhS7crIjHmKVQRlTgc+u0ghsY9KjXU9HufW4HMo4hck9JfmfcAorzv4SfFrTviVoxSQR2eu2qA3lkDww6ebHnkoSRxyVJwc5Vm9ErqPXCiiigAooooAKKKKACkNLRQBSGj6aurnVRp9qNRaPyjeeSvnFOuzfjO32zirgpaKQBRRRTAKKKKACkPNLRQBU0/S9P0pJU0yxtrNJpDLItvEsYdz1YgAZJ7nrVuiigAooooAKKKKACiiigAooooAKKKKACiiigD5J/ar/5Kppv/AGBov/R89fW1fJP7Vf8AyVTTf+wNF/6Pnr62oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD4z/AGef+R/v/wDsGSf+jYq+ja+UvhX4y0/wP4oudR1aG5lhls2gVbZFZtxdGz8zDjCnvXrH/DQvhTP/AB4ax/35i/8AjldlGcYxs2eXiqNSdS8Ucv8ADX/k7f8A7impf+i56+vK+OPhBqMOsftPWWpWyusN5eX88ayABgrwzMAcE84Pqa+x65HuenHZBRRRSGFeJftV/wDJLNN/7DMX/oievba8S/ar/wCSWab/ANhmL/0RPQB4v4Q/5FWz/wCB/wDobVtVi+EP+RVs/wDgf/obVtV4FX+JL1Z+0Zb/ALjR/wAMfyQUUUVmd4UUUUAFFFFABRRRQAUUUUAFFFFAHrfwV0dbvTtcnvrcTWVyFtCkjbo5RhjIrR5w3DL1HRiB1Nea/F74CyeDrZvE/gNrqXT7ctLdWpfdLZjcSJEYctGowDnLLjcSwyV9D+DV3JZi6ydNgtp7qKKWae5KzSMUfZGiZwSWwQTjPzgbsfL66uo2UkNxMl5A0VqzJcSCVSsLKMsGOflIHUHpXs4Zr2SR+UcQQm8xqN6p2/JI+PvCfj2PVpIrDVQsN2VCpKDhZm9Mfwk8exOenArtKn+KHww0L4g63/bHw1v7U63cq813YKrKlzhA/mAhcRyEsqnftVmJyVYNu8z8K+M7nT76TRfFRlikjkaPzbkFZIXBwUk3cjnjJ5B4PHTGrQTXNTPgMzyapSfPCLi97NW+49FopsciSxrJE6ujgMrKcgg9CKdXEfL2a0YUUUUhBRRRQAUUUUAFFFFABTZI0ljaOVFdHBVlYZDA9QRTqKY07anmXiTwVc6DN/bXh2eZVt5BMqxErLbEYIdWBycEZz1HB55I93+Efx/svFX2Hw94tP2TX5MxJdbVWC8YY2jr8kjZPy42kjggsEHK1wni7wCl7i80CGOKfgPbLhFceq9gfXsevXr30cR9mZ9NgM05rU6717/5n2iKWvmf4RfH6+tNUXw38SrtmiZlittTuAFe3YALsnOOVOP9Y3zBs7iQcr9J2tzBeWsVzZzRz28yCSKWJwySKRkMpHBBByCK7j6ElooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPkn9qv/kqmm/9gaL/ANHz19bV8k/tV/8AJVNN/wCwNF/6Pnr62oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDzq5+Anw0u7qa4l8Lxq8rl2EV3PGgJOTtVZAqj0AAA6AYqP/hnz4Y/9Cz/5P3P/AMcr0mjNAHG+GvhJ4H8H6yuq+HtBjtr5UZEmeeWYoG67d7MFJHGRzgkdCQeyFFFABRRRQAV4l+1X/wAks03/ALDMX/oievba8S/ar/5JZpv/AGGYv/RE9AHi/hD/AJFWz/4H/wChtW1WL4Q/5FWz/wCB/wDobVtV4FX+JL1Z+0Zb/uNH/DH8kFFFFZneFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAer/BCxuTdanfIkSwL5cTSSW5Zn4YlUkyAuDsLDDZ+Xpwa1vin8FdF+INrc39pHHp/iQovlXwLBJtoICSqOCCDjeBuGF6hdpw/hMYLXTL/UdV1HyNPt7iIBVv5Y/JkJUBniXClHyBuY4+QgjGSPSYPGuhvpMl/d6lZW8SzTxL/pKsXETkZUDliV2tgAnDr1yCfYw0oxppM/Ls+o1a2PnOEW9UtF1tt5/10sfHljq2vfDnU30PxXpd1AqnKwzLtZBuKl4z0dCQ3IO0kZB659HtLu3vrOO6s5VlhlXcjqeCP89u1ek/E6PwN4/8I6haanfW7XWmsTZ3NtPCZkcorFogXHmIc4ZMjcUIHzBSPmm/TUvhj4oFrb6jDqulyjzYZIZP3VzE2OSuSYpAAAVPzKR3UgmatKFR3g9T4nMsjqzh7ZQcX6aHqdFZ+j65Ya7amfTpt+3HmIRhkJGcEf1HHBwa0K89pp2Z8VOEqcuWSswooopEBRRRQAUUUUAFFFFABRRRQBzPijwXaeIA1zEfs9+Ewsg+7IR03+vpkc/XAFV/hn8Y9Z+FVxL4f1+ymv8ASBKP9GMm2SzJYFmiJ4YEEnZwCSCGXLFuurL8QeH7TxDp5trsbXXJimAy0bevuPUd/wAjXXRxDjpLY9vA5nKjanV1j+R9O6LrOn+IdGttV0W7jvLG7TfDNGeGHT6ggggg4IIIIBFXq+JPDXizxb8GfEkDRStcabIxeaw81vs10DtDEf3ZBtX58ZGBnKnB+tvBXj7w94/0p73w3e+d5O0XFvIpSW3ZlyFdT+I3DKkq2CcGvSTTV0fVwnGceaLujpaKKKZQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB8k/tV/8AJVNN/wCwNF/6Pnr62r5J/ar/AOSqab/2Bov/AEfPX1tQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFJQAEgDJOB60xJopV3RSK69irZrwn4r/ABf0bUPDXijwdKNT0XVFZ7aOeW3PlzhJBnBU52yBSM46NWD4Z8G/C3xBZQXXhPx3qnh6+kQFraXUEjkRu4IIBJz3Bwe1O2nf0F+B9MCiqOiWz2Wg2FrLevqDwW0cbXjnLXBVQDIevLYz171epDCiiigArxL9qv8A5JZpv/YZi/8ARE9e214l+1X/AMks03/sMxf+iJ6APF/CH/Iq2f8AwP8A9DatqsXwh/yKtn/wP/0Nq2q8Cr/El6s/aMt/3Gj/AIY/kgooorM7wooooAKKKKACiiigAooooAKKKKACiiigAooooAK19EtNI1K3nsfEUUd1p0k9u8tqZhE8uHxlXZgqY3HLA78EgFUaRhkUVUZOMuZHPiKEcRSdKezOa8SeGbzwF4im1XwZeTaxoKKJRerC2IUZygiuRgBG3DAzjd8rLgnA6rwr4qt/Elng7Yr2Jf3sOev+0v8As/y6ehPpfwk1fS4dO1jTNdbSYbK4A8xryRUacMCpjIbh0wDx23Hg7uPM/if8FF8Mtf8AiL4fakuoWNhOXu7CGTfPpa+u4MSyqwbOQGUAE7sMw9RKOIppvc/FuIMihCvOnFOytaX3b29ToKK43wn48g1YQ2Gpnyr9vlEmAElPb6MfTpnp1Arsq4ZwlB2kfnNfD1MPPlmrBRRRUHOFFFFABRRRQAUUUUAFFFFAFXUdMs9Wsza6jAs8JIbacjBHcEcg/T1rz6JPEXwo8WRa/wCGZpGhj/5aFSyPGSMxTAYyCcemTgghgMel02SNJomjlRXRwVZWGQwPUEelb0q0qb8j0cHj6mFlbePY9U+Evxa0/wCJejFJBHZ69aoDeWQPDDp5seeShJHHJUnBzlWb0TNfDniTwTc6DN/bXh2eZVt5RMqxkrLbEYIdWBycEZz1HB55I93+Efx/svFX2Hw94tP2TX5MxJdbVWC8bjaOvySNk/LjaSOCCwQepCamro+woV6deHPB3R7bRSClqzcKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD5J/ar/AOSqab/2Bov/AEfPX1tXyT+1X/yVTTf+wNF/6Pnr62oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACkpaQ0AeR/Gr4op4HtX02LRGu72eCKa3ubm1EtnkykNG+SDnYjdP7wrmdY1j4Ba3oN/ex2OnfaLeBpUtoonspZWAJCKQBkkgDjPWvT/AIuSW9v8KdbnvLC01CCKJHktryUxxyqJFJG4EENx8uDkttryHU/HPh/y7e8+I/wZmsVnK+VdRWqnzCeQMlU5/wBkkmlZdl99h69Gz3jwa9jL4F0KTSIpIbBtNt2tY5Tl0iMa7Ax7kLjNbVcn4C8f+G/HOmyf8IzKV+xBEltJIvLeAEfKNvTHBAxkcV1lPYQUUUUAFeJftV/8ks03/sMxf+iJ69trxL9qv/klmm/9hmL/ANET0AeL+EP+RVs/+B/+htW1WL4Q/wCRVs/+B/8AobVtV4FX+JL1Z+0Zb/uNH/DH8kFFFFZneFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV1fgbX7fw8+o3kiJJdQw+bZrLIyxiUBkyQGG44kIC7WPzE5QBmrlKKqMnF3RhiKEcRSdKez3NbxZ8Hz46h1HxF8P7W1gvYb4wto9siwwGEYVCj8ReYMbmCsVIYEEHhuK8MeNrqz1B9H8V+ZDLG5h8ydNjwuvylJAeRyOp5Bzn2+ivgrdRxeFL9Zrq3VVvhiMna6s6oqknPRjhVGByDyc4FT4j/CHw38VoJ9b0G/t4dcjjMS3dtKrwXDqAVWbbkkhflDD5gGGQwVVr2IJVaS5j8bzzLqTxFSjy+6nb00X9f5nAxyJLGskTq8bgMrKchgehBp1eW6Zr2sfD/V7nw94lsZkNtLskt5CA8B6kqeQykHIwcHIIODk+mWl3b31pHdWkqywyjcjqeD/AIfTtXDUoypvyPzrGYGphZa6royaiiisDgCiiigAooooAKKKKACiiigArhPF/gFb3/TNAhSKcYD2y4RXHTK9gfUdD169e7orSFSUHdHTh8TUw8+aDJPhP+0HdwX9v4Z+I8ipGqi3h1WUFZEcEjFwSeR0Xfxgrl85Zh9JV8ieKPBdp4gDXMR+z34TCyD7shHTf6+meo98AVH8K/jFqPwrvZ/D/im3ubvRFLEQJgzWkh5zHuIBRj1XIHO4HOQ3q06sai0PssJjKeKjeO/VH2BRVHRdZ07xDo1tq2i3cd5Y3Sb4Zozww6dOoIIIIOCCCCARV6tTtCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD5J/ar/wCSqab/ANgaL/0fPX1tXyT+1X/yVTTf+wNF/wCj56+tqACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA57x54Wh8a+B9T8P3M5t0vIwBMP4HVg6k+o3KMjuM15LrT/GLUvC154S1Lw5o2vxXcBthq0NwoXBGPMILD5h94HaMEDivQfjSN3wb8Qr/aA07dAg885wcyL8hxzh/uenzc8V5B4a8H/C3X7O3ufCnjzVPDt9KgzbS6gkUiPjkEEAk/Q4Paj+u4X7npHhDwvr2nfFpdS1K0K29v4WttOur4Mu3ULsMrNKAOTgArlgDx6EV6gKpaJbPZaDYWst6+oPBbRxteOctcEKAZCeeWxnr3q9SQ3qFFFFMQV4l+1X/wAks03/ALDMX/oievba8S/ar/5JZpv/AGGYv/RE9AHi/hD/AJFWz/4H/wChtW1WL4Q/5FWz/wCB/wDobVtV4FX+JL1Z+0Zb/uNH/DH8kFFFFZneFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFdd8PtV03RdTmvdTsbW6I2rC9w6r5DBWfzBkk8FAPlRm54OcI/I0VUZOMuZHPiKEcRSlSlsz2G98P6f8bPDN5ba5d2RmVVudPks42M2lO5dfLYkDeCI1LLxuJJ4AjYfPOt6H4t+DPiSGy1pVltZ18xGhkZra6HG7YSBh14ByARxwVIz758FrzR7KPVHu737NfHGVmuAkbRBS2VUnkrtcsSPlGMYy2fRNd0fwv4+0NNN1iO01axuCZ4lSbqY2wXRkIIwW2kqf4iD1wfYoyVSmuY/Jc7wMKWLqUlH3NOnl/Wp88aPrlhrtqZ9Om37cb0IwyEjOCP6jjg4NaFcP44+HOvfCfXhrPh5ptS8OyqJbfUY13oI2IAjnK8A5ZQG4DZBXByF2fCviq38SWeDtivY1/ew56/7S/wCz/Lp6E8lag4ax2PzvH5ZPDtzhrH8Ub9FFFcp4wUUUUAFFFFABRRRQAUUUUAFZGv8Ahux8QWbR3UapPtxHcKo3pjOBnuOenv2PNa9FVGTi7o0p1J0pKcHZnnvhXxr4x+DOsLDGfN0qefzZ7FyDDdAfKSrYJjbGORg8JuBAAr648H+N9B8c6OmoeHb+OcFFaa3LATWxORtkTOVOVb2OCQSOa+fdV0q01nT3s7+PfG3II+8h7MD2P/6ulefKdf8AhL4ug13w3cN5QYqruMpKh5MMqjGQce3QMMEfL6dGup6Pc+uwOYwxC5JaSPuQUV5/8Lfi5pHxNsZhBF/Z2rW2Wn06SXewTOBIjYG9eQDwCpOCOVLegV0nrBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHyT+1X/AMlU03/sDRf+j56+tq+Sf2q/+Sqab/2Bov8A0fPX1tQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFJS0hoA5n4jeI7bwn8PdV1u9skv4rWNf9GkAKyMzqig5B43MM15Naaf4P8AEPhfxNd+Nvh3Bp2teHCr6lZ6ZiN/LZd4lUqyj7oY4yeF98V2fib4g/DfxTZa14O1/XYrU75LK5ScNEY5EbG5WYbcqygg8jIrz21+Hnjy4l1yLwz440HW7HxFbRW17fySbpXhjjMa8KGAOxiCcnPrnmhxXVApdme9+GY9Oi8KaTHobF9MSyhWzYknMIQbDk9flxWpWd4f0pNC8N6bpEUhlj0+0itVkYYLBECgn64rRoAKKKKACvEv2q/+SWab/wBhmL/0RPXtteJftV/8ks03/sMxf+iJ6APF/CH/ACKtn/wP/wBDatqsXwh/yKtn/wAD/wDQ2rarwKv8SXqz9oy3/caP+GP5IKKKKzO8KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD1L4LW8t++tWt0I7jSjAI5rWZmZXaTg/u/uEFUIYkZ4AHBNedfFj4B3fg2K48T+CpprjTIZTNLZgEzWCcHcrZJkRTnJ4ZRgndhmHqfwWkvU0u9Fnb6bLE10vns07R3CLtHJARty4ztBK8h+eePS9U1vS9FWJtWv7e0ErBY/OkCljkDgegLDJ6AcnAr2cNZUVc/KM+jKrmU4xV9tFq9l0Pkbwn48g1UQ2GqHyr9vlEmAElPb6MfTpkcdQK7Kr/xZ+Btj4gvbjUPhlBaw6tZNHFf6NCVgRgygrIgOFQ7SMjhWwSMMGDeW+GPG11Z6g+j+K/Miljcw+ZOmx4XX5SkgPI5HJPIOc+2VbD/AGoH55mGUuN6lJW8v8j0OiiiuE+a2CiiikAUUUUAFFFFABRRRQAU2SNJo2jlRXRwVZWGQwPUEHqKdRT21Gm07o801zwnqfhe+bXfCl5cWyw5ZWtpnSe3BBDYYYO3BIznOCc9Ca95+EPx60/xZa2mieLbiOy8RM6wRSFNsV+SDhgQNqOcYKnALEbfvbV5GuA8X+AYpIGvtAg2SplpbZM4cdcqOxH93p6eh76OIv7sz6bAZpzWp1t+j/zPtUUtfNnwn/aDu7fULfwz8R5FSNVFvDq02VkRwSMXBJ5HRd+AQVy+csw+k67j6EKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD5J/ar/5Kppv/YGi/wDR89fW1fJP7Vf/ACVTTf8AsDRf+j56+tqACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigApDS0UAc5rHgDwnr8ry6x4e066mkOXme2XzG/4EBn9a4q//AGc/A87+bpS6jo845SWzvGyp9t+6vTNU1Ww0bTpL7VruGztIyoeedwiJuYKMk8DJIH41bFTy21Q+Z7HMaNrFlpOvWXgEy3dzqFnokV39qmAImiVvJ3M2c7ywyeO/WuoFebf83Tf9yZ/7e16TVCCiiigArxL9qv8A5JZpv/YZi/8ARE9e214l+1X/AMks03/sMxf+iJ6APF/CH/Iq2f8AwP8A9DatqsXwh/yKtn/wP/0Nq2q8Cr/El6s/aMt/3Gj/AIY/kgooorM7wooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDvfhPqkWk+Iw81zbxrdzR2RieLdI29ZCrIw+YAOiKe3zjOMA11nxV+CGkfELztVs3/s7xCsOyO4XiK4IxtEwwScAFQw5AIzuChax/hb/AGbqOhzaUfsseqx6pbXkTT7Q0iIysQh+8SFSXoMDf1+Y17BFqNlcWcd3b3lvLbSMESZJQUZi20AMDgktx9eK9jC6Uz8u4j9/GuSi01p66aP56/cfEela9qvgHWbrw94ps54vszlZLdgC8Ddcrzgqcg8HBBDA88+k2l3Bf2kd1ZyrNDIMo6ng/wCfSvV/iLo/gT4keHDpuq69pcNzFl7O+S7iMls57j5uVOBuXOCAOhCsPl+8t/EHwr1lLW4ubTUNPnbes1lOJra4IA3BHxlXXcMjAI+UkFSpKq0Y1NYPU+FzHJp1F7WMXF+mjPT6Ko6TrNjrdmtxp86yDALpkb489mHbofr2q9XnNNOzPjpwlCXLJWYUUUUiAooooAKKKKACiiigAooooA5jxV4KtvEJ+0wOttfKuC+3Ky8cBv0+b07HjDfhX8YtS+Fd5N4e8U29zd6IpYi3jwZbSQ85jyQCjHquQOdwOch+prJ1/wAN2PiCzaO5jVJ9uI7hVG9MZwM9xz09+x5rro4hx0lse3gMzdG1OrrH8j6f0XWdO8Q6Nbatot3HeWN0m+GaM8MOn1BBBBBwQQQcEGr1fE3hXxr4x+DOsJFGfO0qefzZ7FyDDdAfKSrYJjbGORg8JuBAAr658HeN9B8daMmo+Hb+OcFFaa3LATWxORtkTOVOVb2OCQSOa9JNNXR9XGUZrmi7o6CiiimUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAfJP7Vf8AyVTTf+wNF/6Pnr62r5J/ar/5Kppv/YGi/wDR89fW1ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUhpaKAPG/j34AvvEWhz6zYeIZrIRQQWz6bNcCK1uf3+VLEsFDbnGCcjKqOOtUdW8K/G9NIvNKh8R6TrdnfQNbtLLGIpUVgVJBCjBweuT7V6P8TbrQbP4c6tN4vs5r3RwiLcQQDLvukUJt5HO8qc5GMV822Wt+MrZNO0bWvEXiDwp4Nu5nSx1C9tyZVj42I0gwQMY5ztHPGBwXe1wtdbH1L4e0T+y9F0uPUDHd6pZ6fFZzX5XMku1V3fOfmwWG7BPWtgVn6BZR6b4c02xgumvIrW0ihS5dgzTBUADkjqTjOfetCgAooooAK8S/ar/AOSWab/2GYv/AERPXtteJftV/wDJLNN/7DMX/oiegDxfwh/yKtn/AMD/APQ2rarF8If8irZ/8D/9DatqvAq/xJerP2jLf9xo/wCGP5IKKKKzO8KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACtfRLTSNSt57HxFFHdadJPbvLamYRPLh8ZV2YKmNxywO/BIBVGkYZFFVGTjLmRz4ihHEUnSnszmfFPh2b4c+IF1bwpqY1TQp3K291j5lBJ/cXCcFWwpIJADhdy4wQvW+GfFdp4lt38pfIuo+ZLdmyQP7wPcfy/LPqPwZutPuLHWNE1GOxYXRXEUyqXulZGDoQfvoAucY43NnrXl/xQ+B+oeDbrUPEvgS4M+j2jbpraGVjdaeCuWBxy0aqVOc7grjIIBc+qorEU1J7n4nn+S04YmdFX02b7eZuUVx/hLx1b6tDHaapIsOoZCAkYWY9iOwPt3PTrgdhXBOEoOzPzuvh6mHnyTQUUUVBgFFFFABRRRQAUUUUAFFFFAFPVdKtNZ097O/j3xtyCPvIezA9j/8Aq6V58ra/8JfF0Gu+HLhvKBKo7DKSoeTDKoxkHHt0DDBHy+m02SNJo2jlRXRwVZWGQwPUEHqK3pVpU35Ho4LHzwsrbx7Hrvw1+LWg/Eu1lXThJZanbIr3Gn3BG8AgZdCPvoGO3dgHpkLuXPd5r4i1Pw1q3gzWF8S+D7qSA2biaMxnMkHXPUYZMcEHOQSCCMmvevg78c7HxjYxaP4rurex8QxbY0kkZY49QyQqlOgEhJAKDqTlRjKr6kJxmro+xo16deHPB3R7JRSClqzYKKKKACiiigAooooAKKKKACiiigD5J/ar/wCSqab/ANgaL/0fPX1tXyT+1X/yVTTf+wNF/wCj56+tqACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoopKAOT+KHia48HfDXV9dsoI57i0RPKSVcqGaRUDEd8Fs/hXDWfirV9Q8CeONG+IGk6brep+Gokmu4UbZBdW7x+apDAHDBVYggDkL0PNdZ8T/GnhLw94Z1Cw8WPFdia2XzNLSRRPPFI/l7kUkZx8xyDkbSe1edX3wNk0mx1e60v4jXln4fu7YHUfNi853t4kOAXVhuCpkYx04o9ULTuez+ETYHwVoh0ZXTTjp8BtFkOWWLy12A++3FbFZ3h23sLPwzplto0om06GzijtJA+4PEEAQ7u+Vxz3rRoGFFFFABXiX7Vf/JLNN/7DMX/oievba8S/ar/5JZpv/YZi/wDRE9AHi/hD/kVbP/gf/obVtVi+EP8AkVbP/gf/AKG1bVeBV/iS9WftGW/7jR/wx/JBRRRWZ3hRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFdd4C8RXPh2TUJbJdLE88aRRSX7lSH3ZCrjnDAHJJVQQhZhgA8jRVRk4u6OfEUIYik6U9mbnxA+Eug+LNEm8UfCOHbdW2X1DRYwwY7stmND91hkjYvyMFwnK4bhvDXji5tb46N4qVoJYWMBlmUpJG6kgrKD0PbPBBHPcj6C+BjsdL1dDFbhVmjIkUjzWJU5Dc52jA25GMl8E84z/iR8KfDfxdnn1Pwvq9nb69ZgRzzxfvIrn5MxrJtP0AkGcAMpDbQF9iNq1Nc+7PxvOsqpRxFSgk3GNtd7XS6nH0leX6Tr2q+AdZuvD3imzni+zOVkt2ALwN1yvOCrZB4OCCGB559KtLuC+tI7mzlWWGQZR1PB/wAPpXBVpSpvyPzvGYKphpa6ruTUUUVicAUUUUAFFFFABRRRQAUUUUAFefeLfh9G8UuoaCjCXJeS0XoR/sDsep2/l0APoNFaU6kqbujqw2KqYafNBk3wk/aJKmx8N/EB8f8ALKLW5JPoEWcEfUGXP93cPvPX0gK+P/F3gqHxABc2ZS3vxgF24WUf7WO47H8PTFr4VfGXVvh7rX/CO+N5bq40TcsWZSZJNPwAqlOpMWAMoOg+Ze4f1adWNRaH2WFxlPExvHfsfW9FUdF1nTvEOjW2raLdx3ljdJvhmjPDDv15BByCDyCCCARir1anYFFFFABRRRQAUUUUAFFFFAHyT+1X/wAlU03/ALA0X/o+evravkn9qv8A5Kppv/YGi/8AR89fW1ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUGiigDzj4weA/CfiXwre6r4mkj02ezgULq+ws9uivnbtBG4EsRt9W45xXkMfhz4NaoJIfD/AMQdT0SKcbJreWRkjkXPQ71GePUmvdPizpcmt/C3WtOg02fVJZ4kEdrbuFdmEikMCf7pG7HfbjvXj6eOvCQsIbb4p/CyTTbuNfLmuotKVYyRxkH5WUewzj1padPzsPW3/AufQPh+zstP8N6bZ6RIJbC3tIorWQOHDxKgCHcOuQBz3rQrM8NSadL4V0qTQk2aY9lC1muCNsJQbBg8/dx15rTpiCiiigArxL9qv/klmm/9hmL/ANET17bXiX7Vf/JLNN/7DMX/AKInoA8X8If8irZ/8D/9DatqsXwh/wAirZ/8D/8AQ2rarwKv8SXqz9oy3/caP+GP5IKKKKzO8KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK67wH4gn0FtQaC++ypJGTKAYixAjlCsqyYDlXZDtDgnkbW528jRVRk4y5kc+IoQxFJ0p7P5nrMnhjTPjb4f1ca7HbLeRSoun6vbWhjlgGzIQ7h8ygsxZPMYZdsEfI5+f9T0vxj8HtcjsddtdtrcOzx4cPBdKp2lkcfdPQ4OGAKbl6Cvof4La9ZW2l3ul3l7bwStdK8EcrKjSs6hcKS3zHKDgLxkcnOB23ivQvDXjzTLvwtrb29y+0SGGOVftFs2PllUclSNw5xghsEEEg+zSaqUlzH5JnWCjDF1KKh7q8ullr/XU+f9J1mx1uzW40+dZBgF0yN8ZPZh2PB+var1cB478Ean8JPFJv8AQrwahorztBDdqwcK45a2nC8CQDtxuA3DBBC9F4Z8V2niWB/KXyLqPmS3ZskD+8D3H8vyzx1qDh70dUfnmPyyeGfND4fyN2iiiuU8YKKKKACiiigAooooAKKKKACsfxB4Y0/xFbkXSbLhUKxXC/eTv/wIZ7H1OMda2KKqMnF3RpTqTpS54OzPP/Bvj7xb8F9WntVt1utMuZQ0tpPu8qXBXLxOPuuV4zgjkblJUAfXfhDxdpHjfw5BrWgXHnW0vyujYEkLj70br/CwyOOhBBBIIJ+eNV0q01nT3s7+PfG/II+8h7MD2I/zxmvO4f8AhIvhJ4ptdc0G63KPl8zYfLmU8tDKuehx0z2BBBGR6dGup6Pc+vwOYwxC5ZaS/M+5xRXB/DT4taB8S7WVdOEllqdsivcWFwRvAIGXQj76Bjt3YB6ZC7lz3ldJ6oUUUUAFFFFABRRRQB8k/tV/8lU03/sDRf8Ao+evravkn9qv/kqmm/8AYGi/9Hz19bUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQByHxV8SX3hH4YazrekhTeW0aCIsuQheRU3Y77d2fTjmvOLyw+LXgfRZPElx4lsfFem28Yub/T5owN0QGXKNjsMnII6Zwelem/EvVtK0T4ba1feIbNr7Tlt/LntlODKJGCBQe2Sw57de1eTax8IdU0PwjO8vxA1zTvCywK13pkkbXD28JxvT5GwQMnOFxgE4Iov0YWPc9C1C11bw/p+o6emy0vLWKeBdu3ajqGUY7cEcVfqhodtZWfh/T7XSWD2ENrHHbMrbgYgoCEHv8oFX6ACiiigArxL9qv/AJJZpv8A2GYv/RE9e214l+1X/wAks03/ALDMX/oiegDxfwh/yKtn/wAD/wDQ2rarF8If8irZ/wDA/wD0Nq2q8Cr/ABJerP2jLf8AcaP+GP5IKKKKzO8KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD1X4JwxXcfiGyurQXNrcRRJMJFVo2U+YCjKTzuDHjBGAc44z5r8U/gTqvgm4vPE/giSSXRYf3rQRyN9pslOd5z/ABxrx82dwDfMCFZz6T8F/wCzzcXCtqVxb34mVhaCVFjuk8twvy43sVy5IBwPkPOOPXbjULS2vLS0nnVLi8Zlgi/ikKqWbA9AB16dB1Ir2cLb2KuflHEMHLMqllul07L/AIH3HyF4T8dW+rRR2eqSLDqGQikjCzH1HYH27np1wOwqb4s/A7SdQ04eIvhcluZ9sk02l2cvmLdIG+eSAAnBUsAUX5cYCgMAr+ceGvHFza350bxUrQSwsYDLMpSSN1JBWUHoe2eCCOe5GNbD/agfneYZTKLc6S9V/keg0UUVwnzYUUUUAFFFFABRRRQAUUUUAFRz28N1C0N1DHNE33kkUMp/A+9SUU0NNp3R5tqnhzWPBeux+I/B080ItG89JI2Be3PQgg/eQgkEHOVyGGOT758HPjnY+MrGPR/Fd1b2PiGLbGkkjLGmoZIVSnQCQkgFB1JyoxlV4yvPvFvw+jaKW/0FGEuS8lovQj/YHr1O38ugB9CjiL+7M+nwGaKVqdbfo/8AM+1xS183fCT9okqbHw38QHx1ii1uST6BFnBH1Blz/d3D7z19Iiu0+gCiiigAooooA+Sf2q/+Sqab/wBgaL/0fPX1tXyT+1X/AMlU03/sDRf+j56+tqACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAyvE/h6x8V+Gb7Q9VVmtb2IxvtPzKeoYe4IBHuK8f1D4d/GFdIm8M2vjLT7/RLiA2rTXcW2YQsNpU/Ix+6cfeJ9691pKWvRhp1Rn+HtJTQPDWmaPFK0yafaRWqyMMFxGgUEj3xWjQKKYBRRRQAV4l+1X/ySzTf+wzF/6Inr22vEv2q/+SWab/2GYv8A0RPQB4v4Q/5FWz/4H/6G1bVYvhD/AJFWz/4H/wChtW1XgVf4kvVn7Rlv+40f8MfyQUUUVmd4UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB3vwn1SLSfEYea5t41u5o7IxPFukbeshVkYfMAHRFPb5xnGAa6f4tfA7T/iJINV0yePS9dRCrTGPMd2AuEWQDkEHADjJC8ENhcZnwt/s3UdDm0o/ZY9Vj1S2vImn2hpERlYhD94kKkvQYG/r8xr2CLUbK4s47u3vLeW2kYIkySqUZi20AMDgkt8v14r2MLpTPy7iP38a2otNaeumj+ev3HxJout6p4E1648OeK7aa2W3k2SxSDLWzddwx95TkHjIIIYZzz6RaXdvf2kdzZyrLDIMo69CK9W+JHhfwJ4+8J3F1q1/p8MsY8u31mBkeWGRQWCAg5cfMxMWeckjDYYfM2oad4v8Ag7rQ0/XrIfZbpmaM798NwqtgvGw6HGOCAwDLuXkUqtGM9YbnweY5S6i9pFWl9yf/AAT0miqelaraazp6XlhJvjbgg/eRu6sOx/zz1q5XnNNOzPkJwlCTjJWYUUUUiAooooAKKKKACiiigAooooA5Xxd4Li8QKLmzKW9+uAXbhZR/tY7jsfw9MXvhd8bdZ8B6tB4Z8dPNPocKrbIzpulsACcMCBmSPBxt5woXZwNrblY/iDwxp/iG3Iuk2XCoViuF+8nf/gQz2PqcY612UcQ4+7LY9zAZnKl+7q6x/I+pdO1Kx1awjvdKvLe+tJc+XcW0qyRvgkHDKSDggj6irVfFfgX4h+I/gtr1zZT232/TJ8tNYNKUR2xhZY3wdp4AJwcgYIyAV+uPCHi7R/G/hyDW9AuPOtpfldGAEkDj70br2YZHsQQQSCCfRTTV0fVRkpK8djcoooplHyT+1X/yVTTf+wNF/wCj56+tq+Sf2q/+Sqab/wBgaL/0fPX1tQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeZfHvxtrXgX4ewX/hueO2vLnUI7UzPEshjUo7kqGyuT5YHIPBPGcEem14l+1V/yS3Tf+wzF/wCiJ6APKLL4sfG/UrNLvTrnUru2kzsmg0SJ0bBwcEQ4PII/Ci9+LHxv02ze71G51K0to8b5p9FiRFycDJMOByQPxr034M/8kj0X/tv/AOj5KPjN/wAkj1r/ALYf+j466fYrk5jg+tP2vs7dbHVfATxrrXjr4ez3/iSeO5vLbUJLUTpEsZkUIjgsFwuR5hHAHAHfJPpteJfsq/8AJLdS/wCwzL/6Igr22uY7wooooAK8S/ar/wCSWab/ANhmL/0RPXtteJftV/8AJLNN/wCwzF/6InoA8X8If8irZ/8AA/8A0Nq2qxfCH/Iq2f8AwP8A9DatqvAq/wASXqz9oy3/AHGj/hj+SCirFnp17qD7bCzuLptwTEMTOdxBIHA64Vj9FPpWxD4E8TXGipqsGj3EtpIodCmC7KTgERg7yD16dOenNQoyeyOipiKNJ2qTS9Wkc/RWvH4T8QzRzPFol+3kSLFKot23KxXcBtxnpg9OMrnqM34fh14tns47pNEuBHIwUByqOCW28oSGAz3IwBz05pqnN7IiWMw0PiqRXzRzNFbtl4J8S6h5/wBl0a6Jt5EilWRPLKs+MDDYPRgT6AgnA5ok8EeJ4rWGdtBvyk27aFgZmGDg7lHK+24DPbNHJPsP63hr8vtI39V6/lqYVFbVz4O8R2moS2Mmi3r3EKq7rDCZQFbO05TIwcEdeoI6g1fuvhr4us7V55tFlZExkQyJK3JxwqMWPXsKfs59mS8bhVa9SOu2q19DlqK2j4N8SiBZToGpbWYqALVy2QATlcZA5GCRg846HD4fBPiW4sri6h0a6ZLaQRSpsxKrEKceX988Op4HQ5pckuxX1vDpX9ovvRhUVu6l4J8S6RIqX2jXQ3bcNEnmrlm2qNyZGScDGc8j1FDeCfEsekT6nNo11Fa2+fNMqbGUDGTsOGIGeoGOvoaOSfYFi8M0pKpGz21WphUVr/8ACJeJP+hf1T/wCk/wqsdD1YXi2h0u9Fy7FFhNu+9mChiAuM5CspPsQe9Lll2LVejLaS+9FGitSz8Ma7f3X2a00i9kl3BWHkMAhLFPmJGFG5WGTgAq3oauah4E8T6ZPDDc6PcNLOrPGlvidiqlQxwhOACy9fWnySavYh4rDxlyOav2urnP0Vrx+E/EMtqLiHRL+SMyPFlLdmIZDhgQBkYPHPcEdQcEnhPxDDHC8uiX6+fI0USm3bczBdxG3GemT05w2Ohwckuw/rNC9udfejIorXufCevWn2IXGk3SSX3mfZ4fLJlfZ9792PmGOvIHHPSmXXhnWrLSU1O6024js2Z0MpXIRlfYwcdUO7j5sZPSjll2GsRRdrTWui1Wu/8Ak/uZl0VeOh6st4to2l3ouXYosJt33swUMQFxnIVlJ9iD3qzd+E/ENjG8l1ol/HGkYleT7OxVF27slgMDA656cg4INLll2G69FNJyWvmjIorpovh14tmcqmiXAImaD5yqjcASTkn7uBw/3SeASTT7X4a+L7y1SeHRZVR84E0iRNwccq7Bh07iq9nP+VmDx+DW9WP/AIEv8zlqK6Cz8CeJr+CzmtNHuJIr1WeB+ApUDOWJPyA9t2N3bNQp4P8AEEmgyayulXAsI13tKwAJXAO8KfmK4IO4AjGTng0uSfY0+t4a9vaR7brfa33pmLRW7ceCvEVt9s83S5f9Ckjim2MrYeTbsVcE7yd68LkjcM4zUNz4T160+xC40m6SS+8z7PD5ZMr7Pvfux8wx15A456Uckl0COKw8tpr712v+WvpqZFFa/wDwiXiT/oX9U/8AAKT/AArRm+G3iy3mt4ptK2vcyGKIfaYjuYIz4+9x8qMefSmqc3shSxmGj8VSK+aOXorqf+Fa+L/O8v8AsWXd5nl58xMZ2b853Yxj+Lpn5c54qha+DvEd7p73trot7JbqqOGEJBdW+6UHVx3+UHA5PFHs59mJY3CyV1Uj06rrt9/QxaK6mT4a+L4rqGBtFlLzbtpWRGUYGTuYNtX23EZ7ZrKi8L6/OheHQ9SkUMyFktJCAykhh06ggg+hFJ05rdDjjMNNXjUi/mv66My6KsXWnXtiiPe2dxbrIzohmiZAzIcMBkckHg+hqvU7HRGSkrphRRRQUFFFFAHU6DaW03w98W3M1vFJPb/Y/JlZAWj3SkNtPUZHBx1rv/C3gDw34z+ENraa3pdu73Syg3ccarcRsJXCusmMgjA65GOCCCRXjsd3cw2s1tDcSxwXG3zolchZNpyu4dDg8jPSuu0Cx1ubQ7eSx8dafpUB3bbObV3gaP5jnKDgZOT75z3rroVFGSdr2X6nzWcYGVahKLqcqlNPrty2tp5q55n4/wDAWr/B3xZ9s0m5N5o8kpjguuG2kgP9nnA4D7SD2DDDLggheh8O+KrHxJE32bdFcRgGSCTGR7g9xnjPH0GRXtfhZdEtvDN9pfjXxBoGtm8uvOlE96lwkihYwobzOpBjHUcYFeIfFD4L6p4E1251/wACb7jSbaP7XJEkoafTlJIwyk7nj4bDYPyq277pZu6UI1o32Z+UZtlEZTceq2lbf/gG/RXJeEPG0GswLa6lJHDfrhQWIVZ88Aj/AGv9n8R6Dra86cJQdmfB16FShPkmgoooqDAKKKKACiiigAooooAKKKKYFPVdKtNZ097O/j3xvyCOGRuzA9j/AJ7159aXXiz4Ra9Dqeh37C3eUFlUsYLkLuASZOAflZvpklSCMj02obu0gv7SS2vIllhlXa6MOo/z3relWdN+R6WCzCeGdnrH+tj2b4c/Fbw98R7Ef2XN9n1SOES3emy58yHnaSDgCRc/xL2ZdwUnFdvmvhzV9A1fwT4gt/EPg+a4h+zuZY5Ifme2IByG65QjI5yCCQ2c8/RHwe+N9r8Q92ka6lvp/iFNzJFFlYrtBzmPcSQyjqpJOBuGRuC+nGSmro+wo1oVoKcHoeSftVf8lU03/sDRf+j5q+tq+Sf2qv8AkqWm/wDYGi/9HzV9bVZsFFFRXNzBZ2stzdzRwW8KGSWWVgqooGSxJ4AA5JNAEtFfIPhH44+IZvjVBq2rarcJompXvkTafcXYFtawSHap5G1fL+Vi4CltpyRuavr4UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV4l+1V/ySzTf+w1F/6Inr22vEv2qv8Aklmm/wDYai/9ET0AVfg1/wAkj0X/ALb/APo+Sj4zf8kj1r/th/6Pjo+DP/JI9F/7b/8Ao+Sj4zf8kj1r/th/6Pjr0P8Al18jxP8AmJ+f6lr9lX/klupf9hmX/wBEQ17bXiX7Kv8AyS3Uv+wzL/6Ihr22vPPbCiiigArxL9qv/klmm/8AYZi/9ET17bXiX7Vf/JLNN/7DMX/oiegDxfwh/wAirZ/8D/8AQ2rarF8If8irZ/8AA/8A0Nq2q8Cr/El6s/aMt/3Gj/hj+SPVPghZK+oahdzWqMEVRBO9qWKsMhgsvRThxlepDA9Ac+zV5j8Dp5G8PalbsjiJLoOrmIhSzIAQHzyQFXIwMZByd3HU+P8AxpaeAfB11rl7E05jwkNupwZpGOFXPYdyewB4PSvWw1o0kfmmfzlPMql+ll+COlorxHVPiV8TvD954ds9d0Tw7FceI7pIrUQvKzWwLKGWVd3LYdeVOBg5zmtjU/iT4pufi1qngvwhpOnXptbRH+03ZkRLeQgMWlZScrhgAqrkk9a6Twj1NIoo3kaONEaVt8hVQC7YAyfU4AH0Ap9eL6Z8cb9fhHq3ijWtIgfUNN1A6eIrR2EMsny4bJyVA3c8nOB68aUPjbx7aeANY8R6pb+GLyKDTjeWVzpU8kkRYHmN1LZJAycq2OMZo7j1bPVqK8Q8W/Ha+8P/AA68K6raWllNrGswi4uInjcxQxjhyAGBGWIAyfXrXU6r8Rr2H4t2fhjTUsjpsGnNqOr3UysWgjAJG0hsD+HqD94UbCPR6jSGKJ5GjjRGlbfIyqAXbAGT6nAAz6AV8/aj+0Jrkmnya/o0XhlNKFyIYdKurx31Odd2N4RDhAevI4/2uCet8UfE/wAR2nj7QfDHhfRbW6vNU0/7VLBeFla2Zgdu5gcBV2ksMEnGBgmiw9tD1SWGOdAs0aSKGVwHUEBlIZT9QQCPcUs0MVxC8M8aSxSKUdHUFWU8EEHqDVLQ/wC1xotv/wAJGbI6nt/0g2AcQ7s/w7/mxjHWsP4k+Nl8AeCLrXTZteSRsscUIbaC7HA3HsB1/TvSdkEW+h1lVnsopNUgvyzebBDJCoBG0q7Ixz7/ALsY/GvOdL8UfEO48H6lq15H4RnVbH7VY3ljcyvbgggskg5JIXccqcZAGe9cR8EdR1vwt8PdX8Y68+nHw5dNcX8rIrm9lnDBNo6IFJVsd8nt2Lb36BGTWseuh9AWtrDZwtFbJsRpHlIyT8zuXY8+rMT+NZV5aXcvjTTLsWzvZwWtxGZo59uyRzGQHTIyuEOMbvmIJAwDXkGs/F74j6N4Jt/F114f0GPTNVdU063MsrXEW/5kaQZAcFQeF2nkHjpXR+KfiR4p0rx/oPhDQdL0/UNTv9P865WTeiRSEEBtwb5Y12sxGCSBgcmhxvp/WmppCtKEnLdtP8dG/wAT1OOKKBCsMaRqWZyEUAFmJLH6kkk+pJp9fOPxK/4WBrfxG8F+G9Sbw41+sn2+3S288QtInzEy7vm2/IQNvJ5JxkAfQWl/2gNItf7aNsdQ8pftJtAwi8zHzbN3O3PTPNNbXMm9SeS0tprqG5mt4pJ7fd5MrIC0e4YbaeoyODjrR9ktvJ8r7PF5fmebs2DG/fv3Y9d3zZ655615pffEfxF4DvHT4k6Ij6Q0u2HXNH3PEoJ+USxH5lOOpHBPABr0T+1LM6P/AGr56/YfI+0ecQQPL27t35c1Olrlc0k0rk/2S283zfs8XmeZ5u/YM79mzdn12/LnrjjpTpoo7iF4Z41likUo6OoKsp4IIPUEV4hP8YPHE/hHUfHWlaBo6eE7d2jt47yaQXcw3eWJODsxvIyvB4IBPWtDXPi34h0Tw94ElTSrO+1jxJiSayhR1yhCkLHlvlb51GWyBycVVv69Rczvv/SPYqK8r8N/EjxKPiNrHhbxnpumxtY6cdRR9KeR9iDadjbvvNhuoC8joc1B4A+I/jLx7eRapYWPh3+wGuTFLaLdudQtkzjzH/h7ZxgE5H1oFset1Xi06yg082ENnbx2ZVkNukSiMq2dw24xg5OfXNeR6d8ab9PA/jDWNatLNLzRdQexs4IEcCZydsYYFiSd2c4xwDwKim+M2tP8JPDWt2Fnp8viPX742cNqyP5ORIyk7Q+7oF/i6sKVr/13HzOK3/pHrer6THrNmlrcT3EMSzRyt9ncIz7GDBd2MgZAOVIbjgirEVrDF5JCbnhj8pJJCXcKcZG9sk52rnJ5IBNeQ+KvjJqNt4ov9A8N3Hhqzl0iIG+vteu2iilkxkxQxqQ7EevPPGBwTXvPjhq8PwW07xamk28Op3t+LOOCRHeKbBO50AYNghSBk9fWiy3KdSfKoX01/wCD+B7ZTHhjkeNpI0dom3xllBKNgjI9DgkfQmsDwjceLLy3nufGFppliJSrWlpZO7yQoRkrMx+UuOB8vHB61uXd1DY2c11dOI4YUaSRz0VQMk/lQ9NyF5E1NhiiggjhgjWKKNQiIihVVRwAAOgFfPuoftCa2+nya/o0XhlNKW58mHSrq8Z9TnXdjeEQ4QHr8w49+M9f4l+KWv2PxA0Dw14d0OG8udU0/wC1TW1wWR4GYHbucHCqu0lvlJwMDk0w1Wh6rVXVNStNH0q51LUphBaWkTSzSkE7EUZJwOTx6V5f4X+LuoLB4zXx3a2EEvhUr5s2mM3lTbiwCKHOdxZQBkjO7oMVxfxB8e/EDUfg/carq+i6PZ6Fr6rDapDO/wBrgRyGVnz8rhlBHGD8wJAxik/L+rjW+p2PxW8Q2uv+BNEvtGke4029uDNHP9ndVO1SBktgrnLYBXnBORjnyKvSviBoUegfD7wvZC6u98FvFbfZjMoh/dod0nl9S5LY3AYA4OMjPmteRjNKzR+qcNW/s2DXn+YUUUVyH0QUUUUAFFFFABXY/DTWrXQ/E6XF3sRXZY3laTZsjbKk5MiggO0ZIKtwCwxt546iqhJwkpI58TQjiKMqMtpKxqeOfg3aeJtP1Txd8L7NkgiuWJ01JA3nqAN7QxBcxYOSIySWDfKEwqNxnhP4hBvI0/XW5+6l4zdfQP8A/FfTPc1758GXjsdF1vU7y922ttgmASufKAUs8hjHHICgNgk7GA9z4ufBax+JKjWfDk9rZ6/G3lSTOT5N0qnaVkKgkOmCAwBPy7T2K+xBKvTXNufjeeZZRjiJ0Le6tn8l179/yscNRXmmk6/q/gnxBceHvF8M8P2dxFJHN8z2xAGCOu5MYIxkEYK57+i2l3BfWkdzZyrLDKNyOvQiuCpSlTep+dYvBVMLK0tV3JqKKKxOEKKKKACiiigAooooAKKKKACvPPFnw+DefqGhDB+81mq/mU/nt+uOwr0OitKdSVN3R1YbFVMNPmgeH+KPFuseL59Pn8QXH2q5sLJbJbhh+8lRXdgXP8TfORu6kAE5OSf0Hr4P+JtvDb+JITBFHF5luHfYoG5i75J9T719xaJpUGg6Bp+kWjSPb2FtHaxNKQWKogUEkADOBzwK9iEuaNz7mjVVWmqi6l4143+0v4uk0D4cxaRZXHk3euTGFgA4Y26DMuGGAMkxoQequwweSPYzXxV8cvFkXif4yXpmt3+x6Q40wIhEckixO3mfMdwBLtJtbH3duVzmqNTN1XwA9h8IdK8U7JvtNxdOZ0MDDZC/EbE5wFymQ2Bu85fQZ+qPgl4uk8Y/CrTbu8uPtF/abrK8c79xeP7pZmyWZozGxbJBLHp0Hz9qfxy07VfDc+hz+D0Sxmg8gRx3qgRLjClAYSAVwCvHBA9Kn/Zh8SvpXxLm0R2k+z61bMoREUjzogZFZieQAglHHUsMjuLny/ZMqbnZ86ProUUgpag1CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArxL9qr/klmm/8AYai/9ET17bXiX7VX/JLNN/7DUX/oiegCr8Gv+SR6L/23/wDR8lHxm/5JHrX/AGw/9Hx0fBn/AJJHov8A23/9HyUfGb/kketf9sP/AEfHXof8uvkeJ/zE/P8AUtfsq/8AJLdS/wCwzL/6Ihr22vEv2Vf+SW6l/wBhmX/0RDXtteee2FFFFABXiX7Vf/JLNN/7DMX/AKInr22vEv2q/wDklmm/9hmL/wBET0AeL+EP+RVs/wDgf/obVtVi+EP+RVs/+B/+htW1XgVf4kvVn7Rlv+40f8MfyR678DZL8f2rEYJW05trCYv8iSjqoXuSpBJHQKueorX+NXg/WfF/hSwHhyGO6vdO1CO8W1lcIs4UEFcsQO+eSO9c/wDCTxJpOh6LqS6lfNDK91CBDLMix7XITegJHIyS57Kq+lesXWuaTYoj3uqWVurs6IZrhEDMhw4GTyQeD6GvVwzSpLX+rn5zn1KrLMZtQ302euiPJ38MeOvFvxf8L+IvFWjW+maRpsckgtYL1JjbSYOA7cFmZgp+UFQAOc5rS8C+FPEeka94/wDEWq6cYtQ1a5b+z4vOjbzI0D+XyGIXOVHzEYxXdQ+L9CfT7C8m1G3tYtQhM0BuJVQELtDKWztDAsAVznOfQ1cfXNJi0+O/k1SySzlbZHctcII3bngNnBPB/I1vzRasn/TPDlh60X70Xv26rp+Z5B4T8JeMfBfwmsdJbwdp/iGS8uJ5NW0q6vI0b5iPLIc5jIAUE9e2O9TeBvhhrej+AfGlre2kWnSeIY5RaaPDc+alnlHCguTgklgCc4wo57D1CDxZ4eubEXcet2HkHbl3uFXaWBKhgSCpIB4ODwfQ0+48T6HawWs0+r2SQ3jMsEpnXZIVB3YbOMDGCemcDqQKbnFp67j+r11K3I737Pfc+ftG+C/i6T4W+IE13Tw2vvbwWOlWhnibyoEmWVsMG2Dcc9T2967bwl8MNbbwL4pn8UPFD4q8UQSRSsGBW2TYUjjyuRjucZ4wOcV6Rp3inR9SsLS7ivYoY76R47UXDiNpyrlPlUnJycYHXkZAPFXrnUbKyWV7y8t7dYVV5DLKqhFYkKTk8AkEDPUg0cyadnuTKjVhLklF3T7edvweh4z8PPDHizw7HpWmT/DHw/aXNo4SbxHJcwM7xhvmYKi+YXK9Mkc4ziuk0PwnrbfH7XvFmr2fkaaLFLPTZPNRvMHy7jtDFl5VuoH3q9FF3bG2juRcRGCXZ5cu8bX3kBcHockgD1yKhvDY32izm6ljfT57djJKJdqGJl5beDwNvOQffNNvW5nyPaxcrkvHz6+dOhh0TwrYeKrKYsl/p11cpCzDgoVLgpgEHOefu4rnv+FE/Cn7F9s/sGL7L5fm+f8A2lcbNmM7t3m4xjnNdd4d8N+GvAWlSabocEOl2jF7t43uGbOAoeQl2JwBtyc4HFGg1GV7JHmHhT4W+JNL+G3jWzFvb6Vd+IVb7HpCXJljtFww2l+m4htuQSOB9AsPgbxbrX7O9z4MvtCh0XULNI0tV+2pKLwq4kZjs4TccjknnOcCvXbLxDo+o3TW+n6na3Ui7ciGUOCWDkAEcE4jc4HIAz0rRoupfh+A5QnTlaas/PzPBdY8I/EXxnF4Lsda8PWulaRpV3D9stor6OVyIwoMrc4C7chUXceWz2rr9E8J62/x917xXq9n5OnCxSz02XzUbzB8u47QSy8huoH3q9Mop3d7/wBamdtLHkXiTw14utvj5Y+LtI0GDW9OWxFoN96kH2UkkMx3ZJxuJ+UHIJHWvUNVe/j0m5bRoYZr8Ifs6XDlYy/bcQM49cc1copdLD63PN4PhP8A27qUerfEzVZPEl3Gd0ViqmGxtz/sxA/Meoyx5HUV1nirQW1vwPquhWBS2a7sZLaHAwqEoQvToOn4Vu0lDV1YE7O5856j4L+KWrfB2x8Ejw5aafBZSpHM66hE8l4gcsGAyFRR1OWLEgYHWu6u/A+rXPxu8NaiLIr4c8P6WYoJ/NT5pdrLt2Z3dCvOMcV6lRT63FbSx5Hpvhfxlp3xH8deL7XSrZ7u6SGHSY7q4XZcxrtDcqSUyqDG7HJGeM1S8F+ANdk+LsfjC78K2ngqzgtnjksLW9Sc3cjAjcRH8oXkHoOVHXJNe00UR0sN638zwPQPhJ4jf4zane67aKnhb+1JdVhzKjC5my3lZUMWG3eTyB0PrUnwl+FPiXTvElpfeN7aO3svD6yppFt5iOXeVyzSnYzYwD35+76ZPuF9qNlpkAm1K8t7OJm2CS4lWNS2CcZJ64B/KmXGradaWUV5dahawWs2PKnkmVUfIyMMTg5Azx2pJqPU09nOauk9Tw+18A+JfDHjLxDL/wAK60bxlbapftd2moXd1AjW25icESKW4yMhQOnBNdL428I+J/FOveAIrjT7f7FptwLvVpLWRViikXaQqKx3FchhwDwe1dtceL9Lh8VWWkDUrJjcLNG6rKGdJ1ZAsZwflJBk4PUqAOeDrzajZW87wz3cEcscJuHR5VDJEODIQTwue/SlGS6PYqeHqxs5RfvK/wCNiyOlY/i7R5fEPg3V9Ht5VhlvrOWCORicKzKQCcdsmuM8R/Cz4Y6he61rWsaMt9fwK13fiLUJvMHyluUEgCkgcDgVp+FfA3w+8E+JJV8MW9nZaxLF5Lwm+eWYpw+NjuSOADwOgoumrMSp1F7yX9aa/ijiPh54Y8V+HY9K0yb4Y+H7S4tHCTeI5LmBneMN8zBUXzC5XpkgZxnFdJonhPXH+P2veLNXsvJ04WKWemyeajeYPl3HaGLLyG6gfertJfFOjx6IuqR3sU0ElvJcQqjjfOsalnCKSCSAOR274rXp8ybv/WpM6U4L3lb/AIB4HF8KPE+pfDnx7Bf2qWes6/qv2u3hedG8yNJN6gspIGSWHJ9M4pdd8I/Ebxtp/hDTNZ8PWulaRpl3ALy1jvY5WdUG1pWIIAG3IVF3H5jk8CvbYtb0yae9iiv7d2sFDXZEg2wDLD5m6AjY2QTkY5xxTNR1/TdM0iTUbi6iaBbdrlNkikyoMcpkgNksoHOCWUdxSUlHX0/Ar2NWUuXld3+p5r8dJZFt9DhWRhE7Ts0YJ2kgIASPUbmx9T615BXpnxkvdKv7rS59J1KK9dvN84Q3nnLHxGFwu4hM4PQDOOc15nXjYl3qs/VsghyZbTi1bfy6sKKKK5z3AooooAKKKKACiiigArrvAfiCfQW1BoL77KkkZMoBiLECOUKyrJgOVdkO0OCeRtbnbyNFVGTjLmRz4ihDEUnSns/meqzeEdK+N+k6pPryRLf2zCHTtWtYXiaBSqtsZD8rgMDlS74LvtKgqx8Bu7XxZ8Itel0zXLBxbvKQpYMYLkLty8L4APysue4yAwBGB9AfCjXbHQPDd9PfzShJtQhgIa4iEcW8YD7WYMOh3HByFGM7Wx3PiXTfCXxE8K32l6pd2V9Yxr5kk0Fyha0YA7ZQ4zsIG7k8EbgcgkH2KUlUppSPybOsvUcTUgoe5ottNkeD6VqtprOnpeWEm+N+CD95G7qR2P8AnnrVyvOfFvgzVvhVrFvqejarBrWjyt5Uep2uDE74BaCVQx2t3AycjBByCF6vw54qsfEkTfZt0VxGAZIJMZHuD3GeM8fQZFcdWg4e9HVH51mGV1MK3KK0/L1NuiiiuY8YKKKKACiiigAooooAKKKKAPKvin/yMdr/ANei/wDob192V8J/FP8A5GO1/wCvRf8A0N6+7K9mj/DR95gf92h6Aaw9Q8FeFtWvpL3VfDWj313LjzLi5sIpJHwABlmUk4AA+grcorU7D488aaLpVr+1fbaRbabZw6a2rabGbKO3VYSrLBuXYBtwdxyMc5NfVmleEvDuhXTXWh6Bpem3DoY2ls7OOFypIJUlQDjIBx7D0r5g8ef8nk2v/Ya0r/0C3r62oABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUZoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8S/aq/wCSWab/ANhmL/0RPW3+0NqPiHSfhU994YvLixaK9h+2XFtKI5EgORw2QwzIYh8vOCf4d1fNVnpXxI+JGimRL3VNc0+C427bzVNyJKF6hZH6hX647n3ppNibUVdnuHwa/wCSR6L/ANt//R8lHxl/5JHrX/bD/wBHx1pfDnQr3w18PtL0rVAi3cCO0qo24KXkZ9ue5AbBxxkHBPWj4jaFe+Jfh9qmlaWqNdzojRK7bQxSRX257EhcDPGSMkda9Cz9nbyPD5l9Yv0v+pX/AGVv+SWal/2GZf8A0RDXttfDF7pfxI+G+iiRr3VND0+e427bPVNqNKV6lY36lU64/hHtX0z+z9e69qXwmttQ8S6pJqb3V1M1rLNIZJVhDbNrsRkneshGSflKjPGB57TT1PcTTV0enUUUUhhXiX7Vf/JLNN/7DMX/AKInr22vEv2q/wDklmm/9hmL/wBET0AeL+EP+RVs/wDgf/obVtVi+EP+RVs/+B/+htW1XgVf4kvVn7Rlv+40f8MfyQUUUVmd4UUUUAFFFFABRRRQAUUUUAFFFFAHqXwc8MTXd3/wkBuYkgtLhoxD5IZ5G8pgfn6qAJQcDO4jkcA16V438VW3grwbqOvXi71tIspHnHmSE7UX8WIGe3WuX+CX/Ik3f/YQf/0XHWB8ft+q6h4I8MbS0Gq6wpmHqqFVI+mJCfwr2cPG1OKXU/Jc9rTq5hU5/s6L0WpeTxT420X4R6bqd7daXfeKdXnRoLfUpYrWJFkORGo3R7iFxxktk98V6F/wkOm2e6DV9V062vre2W4u4TdKvkp0LkMchM8bjXl/xIUa38c/h94bQbobR31GWNeiheVJ9B+6P51k6FommeO/jz421vxBCl9peh+XbxwSqGhd1Ug7lPDbdjHB7tmum6evr9yPBtbfy+9ns7+KNAj0dNWfXNNXTXbYl6buMQsc4wHztJz71Pf6zpelCA6pqNpZC5kEcH2mdY/Nc9FXcRk+wr5h0rRzefso+J72OHYkur/bIIl+7GivGpx9AGH0FdRoGpN8XPHnh68EbS6J4R02K7uW5AlvWQNsHrhlH/fDeop/18rD/wCCe5XviLRNO1GHT9R1iwtL24x5NtPdIkkmTgbVJyeeOK5D4mePo9F+FGra/wCFNUtLi4hZbeC4t5EnVJS6qR3XIBJwfxryDRF8O6p8HfGXj7xrDaX+s6rcTwwNdfO8L7QIo488qQTn5cEKB2FM1HSvL+Cnw08JBSsuv6otxMi8F0ZickemJE59qVm9PT8R7P7/AMD1q88U+KtN0XwXY2Umk3+t6qIjf/2jcRwOU2gyNHGGUseT90NjHSu2vfEWi6bqMNhqOsWFpe3GPJtp7pEkkycDapOTzxxXlN0y6x+1PGETzYPDOiM4ReiyMOn1xKPyrifDqeG9S+D/AIv8feO4bPUNX1S4niia5G5432gRxx55Q5OflwQuOwob0b+f42ElsvRfqdfoXj3xZrXws8e+Jk1VlayuphpLi2ixDHHhsD5cPwcZbPSvUPAusXHiDwDoerXrB7m8sYpZmC4DOVG447c5rxZT/wAIj+xviUiO41SEhV7v50v/AMb5/CvZ/AOlTaJ8PdB026XZPbWESSr/AHX2jcPzzVWtddrIV72fqcB8a9Y0i6FrpcZaTVrKbL4VgsUbICQSeCWyhGM42nkd/Ja9g+N+n3r2un6jJPbtZxTNDHEsbLIrOoPLZIYfuz2XHHXqPH68PFX9q7n61w/yf2dT5H3vrfW+vRfd+L3Ciiiuc94KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPXfg/CmseHdW0XV9IivdIaZZc3ECyRPJ8uUYNwxG1GAA46kjK15V8UfglrPgPVp/EvgVJp9DhU3DKj7pbAA/MpBOXjwc7uSFDb+BubvvhP4m/sKS9S+vLWPTpJIVaKe42SK7ttEkanggcb+hCgHPGD7H/wAJFov2L7Z/bFh9l8zyvP8AtSbN+M7d2cZxzjrXsYaUXSSbPyriDC1Pr83yaStt10X4nyb4Q8bQazAtrqUkcN+uFBYhVnzwCP8Aa/2fxHoOtqr8Sfg94f1pLvXPhPdx3N6qfbbnQ4GBHlN1MCgAqwIJMRyfmAAX5UbhvCfxBD+Tp+utg/dS8ZuvoH/+K+me5rKrQT96Gx+d5lk9SlJyhFp9U9D0OiiiuE+ZCiiigAooooAKKKKAPKvin/yMdr/16L/6G9fdlfCfxT/5GO1/69F/9DevuyvZo/w0feYH/doegUUUVqdh8k+PP+TybX/sNaV/6Bb19bV8k+PP+TybX/sNaV/6Bb19bUABpKWkNAHL+KfiR4S8F3UFt4m1qKyuLgbki2PI23pkhASBnPJwOD6Ulp8SfCV9o+rarZ6zHPYaOQL25jikZE+hC/P/AMBzXkPhPxboOieOPiT4i8YXEH9tR3bWtrZzYM0kS7lVIlPLbsIDjjgZwK5aBZtK/ZT8uJNlz4o1rbEicbhvAwPQfuT+dJXa+78Ru1z362+LPga71y00e38RWz314EMEYV8MXGVUtt2qxyPlJDZOMZqbxJ8UPBnhHVI9N8Q67DaXjgHyQjyMgPTdsU7OufmxxzXmHjXw9Y6X4x+FXgvSreOKO0uTdSBBy2zYzMT6ttck96xfEniCz8MeOpfF3w/8S6T4gTxNcpbXugyIJJ3z8uAPvAE54O3qPvU0rtW7k/5HvFr408P3viZfD1rqSS6m1qLxYURiGhOCGD42nIIOM5pum+OPDuryazHp2ppMdEYpqB8t1WAjdnkgBvutyueleI/FXXJvAvxytdS0m1Y3N54f+yWsUa8eaxdEAA9DtOB6VyYstQ8Dap4o+HWltJda14ij0+0RsEgloy07lvT52GfQk9qS12/p3Ktb+uh9ID4l+ED4PTxS2tRR6M7mOO5ljeMyMCQVVGUMx4PABPBp3hz4jeE/FtjeXXh/WYruKxTfcfu3jaNcE7irANjg84xxXiHjXRl0X4oeDPCv/CR23hvT9E0gSWWpXttHNF5+W3uVkITcxUHJ6HHfFa+oWmh+Hvht478W2fixvFGtX8P2C71SNVSPe+1QsYT5ejqTgkcDpQ9mwtsj1PQ/if4P8SaraaboesreXl5E00UKQSg7Fzktlfk6dGwTx6iusrifhF4at/DHwv0a1itlhnuLZLm6OBueVwGJY9yMhfoAK7WqlZOxKd9TlPEnxQ8G+EdUj03xDrsFpeSAHyQjyFQehbYDsznPzY45qzqnxA8LaJd2dvqus29s97bNdW7PnY8SjJbfjaBjpk89s14b4k8QWfhjx1L4u+H/AIk0nxCnia5jtr3QZEWSd8/LtA+8oJzwQvUfe4rR1zU/C93+1JFH4purO007QdNRLdLtgkCzgB1Xn5RgPkdBlR3wKlXshvQ9j8LeO/DXjW2uJ/DGqxXyWrBZsIyNHnOCVcA4ODg4wcH0rCk+N/w5jnuom8UWu60BMm2KQhsHHyMFxJ1/gz69q8Yur2+vfCnxW8caLFImn6tNFZ2s2wr5sXmbZXA642kc/wC0fQ1N41vvDGqeAPAXgHwlLa30091bGd7YK3lMy7W3sPuyMzEkdflOcU1r+H4ht+P4HvWpfEHwto89jDqurxWb39qbu385HUNEBksSRheOzYJPAGal8KeOvDfjeC4m8L6rHfrbsFlAR0ZCc4yrgHBwcHGDg15i+mWfi/8Aankiu4FubLwzpcZWNxlFmyGXj1HmZ+qj0q18EUGpeNfiH4gUDy7rVzBGV6EIXOfyZaI2f9eYndfgeyUua8q+Kvh668SazZxSfDE+LrW1hJiuv+EgFgI2Y/MmzIJ+6pyab8K/A1tomuXWpS/DUeELlIfLinOum/MwY/Mu3JC42jn3+tC1G9DuPF9/4h0/R1fwnptrf3zybS15P5UNumCTI+PmYAgDavPPtXFfAfxV4l8Z+FtS1jxRqC3ZN80NsqQJGsaqoJxtAJGWxzk/LW98T/GWk+GfBesx3Gq2UGpvp8htbSS4RZpCwKqVQncRu9B2Nc38FdV8PeHfghaTy6tZbbSNrjUTHMJGtzI5I3hclTjAwR2pR+0wl0KOgXnxA+IWv+J7nRfHK6DpOnapJY2sA0iC53BOp3Ng+h5J6+1et6Ra3llpFtbapqB1K8jjCzXZhWLzm7tsXhfoK+avifofw5srCxf4W3AuPFl3fIbc6RqclzKc53Fvnbb1Hoc+wNfS+lpdR6TaJqDiS7WFBO46M+0bj+eaa+EH8RbooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMjxZ4fg8VeEdU0K68tUv7V4RJJEJBExHyybTjJVsMORyo5HWvlT9nnWYrXxFqmkS7Fa+gSWNmkALNET8gX+IkOW46BDx6fYRr4+8f2b/Dn9pc6i0sltZXd6mo+fJtkJhnJE5woyBuMygY3YAPPBNwlyyTMqsOeDifQVFFFekfP+R8+/H2/n1bxrpGgWCLdSQQ/JFbgvKZpmx5ZAzyQkZAxn5u+RX1V4U8PweFfCOl6Fa+WUsLVIS8cQjErAfNJtGcFmyx5PLHk9a+Ufhzby/Ez9o+LVW89rW3u21JmykbxRQkeQGHIPzCFCBkkE89WH2IK82bvJs+hpQ5IKItFFFQaBXiX7Vf8AySzTf+wzF/6Inr22vEv2q/8Aklmm/wDYZi/9ET0AeL+EP+RVs/8Agf8A6G1bVYvhD/kVbP8A4H/6G1bVeBV/iS9WftGW/wC40f8ADH8kFFFFZneFFFFABRRRQAUUUUAFFFFABRRRQB6v8D9MeW61PUXa6SOLy441WRlhlYhs7gOHKgjAPTfnGSCNz4m+FNZ1zxb4H1bRLQ3S6PqfmXaiVE2RMU3N8xGcbOgyaq/BO88rw3qMdxcWqQLeJsUviQO4VfmB4wxChe5IYeleh32uaTpk6w6lqllaSsu8R3FwkbFckZwT0yD+Vezh+WNKLPyfPfa1syqK1+mnayKh8JaK3i8eKGss6ytv9mFyZX4j/u7c7e55xmodL8EeH9GtNVttNsDDHrEjy3w8+RjMzghjksSM5PQjHaqfhXxauprHFquraRNf3E0kMVrp+SQYzJlsl2JVlTcGIUYI65FdTFNHMheCRZFDMhZGBAZSQw47ggg+hFbxkprQ8evh6mHm4TWxh23gjw9ZeDX8K2unLHoskbxNaiVzlXJLfOW3ZyTznNS+GPCWh+DtJOmeG9PSxtDIZCiuzlmPUlmJJPAHJ6AVs1han4y0XSNctdKvr2KOe437mMqBbfaoYeYSwK7gRt45pyklq2RSo1Kr5acbvV6eW5hv8F/h8899O3hm28y/BEzeZIMZOTsw37vP+xt446Vsy+BvDs+oaLey6duuNCj8vTm86QCBcAY27sNwBywPSrMnizw9Dctbza3YRyCNJcPcKoKuMqQScHI547EHoRnOi8WW1j4o1iy13VrC2gS4ijs45ZAki5gV3LdgmTwx75GfuilzxVtTaOErzv7r0V9nqrrb77+hf0/wlouleI9R16xsvL1PUwou7gyu3mBeBwSQv4AVgH4M/D/7VfXH/CNW4lvwyzsJZBw33tg3fu85I+THBx0rs7a8tryMvZ3EVwgxlonDDlQw5HqrKfoQe9UNQ8TaLpenzX17qVulvBN9nkZG3lZe6YXJ3DqRjIGT0ptpK7MY0qkpcsYtv0OC8VeAb/xL4x8LaNFYrZ+C/D6LcOfNBFxIvyxwhNxbCgDkjozc16Lql1c2VgZbG0+1z+ZHGsW8qPmdVLEhWICg7icHgGsvRfGmla5qD2MMiw3KqrJG9zBIZQd33fLkbJAQkjqAQe9atxq1haSTpeXcVv8AZ40lmaZtiorsyoSx45KMOv8AMUlJOOjNHQqUqqjOG1tPL5d/I8K8ba74n1XwjoMniD7Klreb5oViiZJZCgC75AeBkNkbcAhs46Y4Wu3+J17Hq2rWeq2esLe2d7CJIrLzgz2LbEDKyAkKTweOpDDtk8RXiVm+d63P13K4pYSLUVG93ZK1tXp8tr9bBRRRWR6QUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHq/wAIfEmj6NourR6rPa2TxyLN50kgDzLtPyBfvNt2k4GeX6etn4w/BC2+IW3V9Ckt9P8AEKbVeWXKxXaDjEm0EhlHRgCcDacjaVwvhVPZI2ox6pq9lp1t51rMyXDKjzNE7OuxmYAAMo3cNkHHy9a9U1jx3oWkWsc32yK882NpUS2niJZFJBYFnAPIwACWJBwDg49fDTSpLmZ+YZ9hJTzCSoxbbfy2Xl69X8tj5B0nX9X8E+ILjw94vhnh+zuIpI5vme2IAwR13JjBGMgjBXPf0a0u4L60jubOVZYZRuR16EV6b488KeAfiho7TalqNhaapBa4iv47yMy2YLDAkCvtdQxAwSR87bSC2a+YIL3V/htr91pl75N7bK5BNvMHgm4GJIpBkdCM9+zAEcFWjGesNz4LMcmnUTqQi01vpoer0VT0rVbTWdPS8sJN8b8EH7yN3Ujsf/19KuV5zTTsz46cJQk4yVmFFFFIkKKKKAPKvin/AMjHa/8AXov/AKG9fdlfCfxT/wCRjtf+vRf/AEN6+7K9mj/DR95gf92h6BRRRWp2HyT48/5PJtf+w1pX/oFvX1tXyT48/wCTybX/ALDWlf8AoFvX1tQAUhpaKAMuXw1oU2pS6jPounyX00ZikuntUMroRtKlsZII4xnpSN4Z0F7O0s20TTmtrF/MtYTaRlLds53IuMKc9xVDxf430vwcNOS/juLm61O5W2tLS0VWllc9wGYDAyMnPGR610QNHQCpLpGmzapDqc2n2sl/bqUiu2hUyxqc5CuRkA5PAPeq0HhfQLXVn1W20PTYdRckteR2kazMT1JcDJz9a1c0tGwGdeaBo+o6hb3+oaVZXV5akG3uZ7dHkhIORtYjK888GgaFpA1o6x/ZVl/ahXYb77OnnbcYxvxuxjjGa0CaxdO8XaHq/iLUdC06/WfUtMx9rgEbDys9PmI2n8Ccd6XkHmWtW0DR9eijj1zSrHUo4zuRby2SYKe5AYHFMk8NaHLoy6RLounvpikEWTWqGEY5HyY29fatOimByfihPHsdzbx+Ak8MpZLFiUasJwwbPAQRcBcY61m6YPi8dVtf7ZPgkaf5q/aTaC7Mvl5+bZu43Y6Z4rvqKQGVB4X0C01Z9VtdD02HUXJLXkdpGszE9SXA3HP1rivCvwuNv4m8Xar40ttL1VNcvFlgt2j89I4kLbdyyIBuwR0yOK9Krm/HPjjS/AHh9dX1mO5mheZYEitUVpHds4ADMB0BPXtRsw3Rtrp1kunf2etnALLy/K+zeUPL2Yxt29MY7VRt/CXhy0S1S10DS4Fs5TNbLHZxqIZDjLpgfKxwORzxWpDJ5sKSFWTcoO1xgj2PvUlPqLoUbbRtMs9Qub+z060gvLvH2i4igVZJsdN7AZb8adpukado9u8Gkafa2ELuZHjtYVjVnPViFAyTjrVyikMSg0UtMDH1Twl4c1y6W51vQNL1GdUCCW8so5mC5J25YE4yTx71JpnhvQ9Ft54NH0bT9PiuB++jtbVIll4x8wUDPU9fWtSkoAytM8LaBoty9xo2h6bp88gw8tpaRxMw9CVAJrVpaKACikrF/wCEu0MeLx4X+3r/AGz5H2j7L5bfc9d2Nv4ZzQBt0UCigAooozQAUUUUAFFFU9P1jTNW87+ytRtL37PIYpvs06yeW46q20nB9jzQBcNJXOeOfHGmeANAXVtZiuZoXmWBIrVFaR3bOAAzAdAT17VNeeMtD03WtK0fUbz7NqWrLm0tXjYs+OoJUEL+JHtSA3qK5fw7480zxP4m1zRdMgu/O0OUQ3M8iKImckjCEMSSCpzkDpXTg0dLh1sLRVXU9Qg0rSrrUbxitvaQvPKR2VQSf0FZfg3xZZ+N/DFvr2mW11bWlyWEa3aKrnaxUnCswxkHvTA3qKBVTUtV07RrJrzV7+1sLZSA091MsSAngDcxA5oAt0U1JEkjV42V0YZVlOQR606gAorI8VeJbHwj4Zvdd1XzDaWaB5FiUF2yQoABIGSSByRWZJ8RfD1n4f0XV9WuJdNh1zyxZx3MRMjM4BUEJuxwRk5wM9aAOqoNJ2rnvG3jTTvAfh/+2NYgupbXzkhb7KisyFuAxBYcfr7UgOiopsbrIgdCCrDII7inUwCiiigAooooAKKKKACiiigAooooAKKKKACiiigBDXzn+1d4aQ2uh+KYVjV0dtOuGLtucEGSIBfu4G2bJ4PzDr2+ja434t6BP4n+E3iDS7MyfaGtvOiSKIyPK0TCURqo5JYptGP73Q9CAcZ8ONZl1/4daNf3G/zmg8qRnkLs7RsYy5Y9SxXd+PU9aj+JWv8A/CN/D3VL1JPLuJIvs9uRN5b+ZJ8oKHruUEvgc/IenUeefs7a6rW2reH5GQOri9hUKdzAgJJk9MDEeBwfmPXsftE68q22k6BGyF2c3swKncoAKR4PTBzJkcn5R0793P8Aurnj+x/2nl+Z0n7J+g7NK8QeIZY7dvOmjsoH25lTYu+QZxwreZF0PJTkcCvogVyXwr0H/hGvhV4e0xkuIpUslmmiuV2yRyy5lkUjAxh3YYIyAMHnmutrhPYCiiigArxL9qv/AJJZpv8A2GYv/RE9e214l+1X/wAks03/ALDMX/oiegDxfwh/yKtn/wAD/wDQ2rarF8If8irZ/wDA/wD0Nq2q8Cr/ABJerP2jLf8AcaP+GP5IKKKKzO8KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOp0G0tpvh74tuZreKSe3+x+TKyAtHulIbaeoyODjrXoPhXwL4f8AGPwat9O1rT4mW98xnuIkVZldZZAkgfGdygkDORgkEEEg+Nx3dzDazW0NxLHBcbfOiVyFk2nK7h0ODyM9K67QLHW5tDt5LHx1p+lQHdts5tXeBo/mOcoOBk5PvnPeuuhU5ZJpdP1Pms4wMq9CUZVOVSmn1eija2nmrnlfjTwfrfwc8VGKx1IajZARF7mKMrGWZWIimTJCthXIGTlfmBByB1fh/wAUWHiK3BtX2XCoGlt2+8nOPxGe49RnHSvXfCOnaJZWerp408S6Brh1RohLFPdpcI6x5KljJ945IwCONo59PFfi18JL34b+JIdZ8GvLJpdw0ksMKMXms9il3BHJeIKCd/OBw/Yv2uCrRu9GflWcZPTlUcIXbS0lZ66K/wAk7/I6aiuV8IeNIvEINteCOC/GSEXhZR6rnnI7jPuO+Oqrz5wcHZnwFahUoT5JrUKKKKgxPKvin/yMdr/16L/6G9fdlfCfxT/5GO1/69F/9DevuyvZo/w0feYH/doegUUhryn4rfHGD4Za/ZaQuhSapcXFr9qdjdCBEUsyqAdrEnKNngY465ONTsPIPHn/ACeTa/8AYZ0r/wBAt6+tq+E9e+Iv9t/GSLx5/ZfkeXe2t19h+0bs+QIxt8zaPveX128Z6HFev237WsD3cS3fg2SKAuBLJFqQd1XPJVTEoY46AkZ9R1oA+jaQ8UUGkB4xo7/8Jr+03ql5PiSy8J2gtrZOoEz8M2PXJkGf9lfSo/DPiPx74+8a+KYNJ8QxaRoGl6j5Udy1jFNJhSQYkBAGCAWLNkj5cdTUvwgiaP4gfFGONFS8Orbl3nsWlKZ745zXUfCnwBe+CfBd1pmuT29xf311LcXMtq7MrFwBwWVT0HpQrqK9PxeoOzb9fwPJ9Z+OOsa9qGrv4e8VR6J9klaHStJt9HN7PqeOjM5Uqm7sB0HY4yex1Xx741vE8IeE9Njt9K8W65a/ab+eWHeLGMZO4RnI3EKxw3QjHfId4T+H3xL8D6fN4e8O614cGitcPJFeXFvM93EG6kIPkJ9iSPeq3xAjGl/GSw1/RfF3hzS9YtdMEN1a6/I0SNExYB1K4DN1+UEYwD0NPRJD6sm8M+KPGlt8aLvwn4j8Q2+p6fo2mvdXFxBZJA0+QpUyDB2kb+ikDA781geG/iZd+H/hLrnju9tLO41PWNWa309Fs44TLx8vmGNQX2/OfmJJxjIzmk+FWha14ksfiNrVrqKXt5rBewstTuFMccxAYNIAAdqfMuAAcYx2rptQ+Cl1efBfQ/CkGoW9rqukTC7ScBnhebLFgcgHHznnHYcUWstfL8Xr+AtL/wBdv8zL13xJ8Sfh/qPhjUfEfiKz1aDWbtbe50iOwSMW5bGQki/M2M9T3xwa0brxX438RfGrXfCvhPU7ex0ywtI1mup7VJRauQGLqOC7knaFZtuATjitGy+Hvi3xJ4y0vX/ibqelyx6KfMsdO0hJBEZeD5jmQZzkDj2GMcg2vBvgDW/D17411W+uLKXU9fuXktWikcrGmH8sPlRjBbnAPTvQ9F9//ABf5Dfgj4w1zxh4QvrjxHcR3k9nqElrHdxxCPz1UKdxUYH8XYDjFVtT8d6nonx6m0bU9QWPw6uiNfCFokG1lBLNvxuPCNxnHtW98KPBF14A8A22i6hNBNeCWSWeS3JKFmY4wSAT8u0ciuU+KXwe1bx54+03VrDUbaz09bZbS/VnZZXi8wswQBSDkMRyRRLdW/rQFazv/Wpz/hH4063deH/HuteIZfKXT4YrjSraSJF8oTb/AClyAC2cx8knNZHjm98V674X+Gmi6s66n4g1a7Oous0awqAMeWrqgAACucnGeDXYa18EL3WfinJqT3lpb+Ep2tZLjTo2bfMbeMKiFdu3Zn/a6HpnGOpv/Aup6j8bdL8W3E1mdJ0ywaCCDcxlErbgWxt24w3XdnijTR/1p/mD62/q5z/hLxZ4ssvjFrfhTxTrVtrNnZ6b9uaaKzW3+zt8h2DHUYf+IknAORzWZ8O/FvjjxVod14u1vxFHp3hzTrqaZolsImlvIUG4xlsAIqgYDDLE7sngVup8NfEKeIfiBra3lgLzxDa/ZdNPmP8AuV2lcyHZx0X7u7pWz4d+HX9m/BdfA97NGkstlLbzzwZZQ8m4swzgkAt3xSu+W/Ww9L26XPGn+Nfi7xDE2o+HPEUceqyXIW18J2eitcFot2NzzsvXHJ2n/vnoO+8UeMfG918VdB8I+GLi30+4uNL+0akJYVljt2YHLcjcSmOBkAkrng1e8F+E/if4bsNN0CfV/Dkeh2DqPtFvBK93JEGzswwCDIyM8kZ71q6J4F1O0+M2veM9UntZLe7tUtbGOJ2MkaALu3AqAOV7E9TVaXX9dCXfVnB+M/ijqnhrxHaeCbjxpBp89pbCXU/Ek2ledI8jfMsaW8YKr8pHXt3BHzdr8GvEXinxH4evrjxWJJ4o7opYX8tp9me8ix98xjgDpgjjkjtVDUvAPjTRvidqnizwDfaGw1eFEurbWFlwhUAZUx8n7ueo69DXoXh+21e10WGPxHfQ32oks00tvD5UYyxIVV64AwMnk4yaUfhv1HLfQ8+8UeK/E/iD4oDwJ4E1KDRzZWwu9T1SS2W4aPONsao3yk/Mp5xnPUY5wvCfxA8XbviFdeJNXgvLbwtbtBB9ntUjWWZd48zpnJKDK525bgVu3vw78X6f8U9V8S+DtX0q1ttbgSK7N9C8ktuVAG+JRhWPy5G5gOTkGsex+DXiTTvg/wCIvDUOo6fJrOt3/nSXck0hQxblOGby87iA2fl/i61OvL8vxHpc5q9+IHxQ034T6N40vdcs4vOuVhjsTYIz36sWId2AG3hcBUA+XnOa6j4h/ETW7H4kWHhdPENv4KsZbNbg6rcWQufOkPGwbvlVR6nHIPPQVt+Lfhhf674d8GaFp89pFp+h3MEl4JXfMiRqFwgCnJI3dcdaq+OvAnxA8aLe6Fc6n4bfw9c3PmxXM9pIb21TOQqAfISBxuyCRnkZq9L/ADJW1/I9G0BdSTw/aDW7q3vb8R/vri1TbHKc8MB2yMV5H4d8XXVxq3xO8XXAtTBowe1sJVs4Vm/dhuDIFDOMqmAzEc167pul/wBjeG7XStOYsLO1S3haZuuxdqlj+HNeU2Xwh8S2PwQ1fwpFfaadc1e8Nxc3Jlk8kqWUkZ2bslUx93vUy1bsOOyucre/ED4oad8J9G8a3uuWcImuVhjsjYIz36sWO92AG3hcBUA+XnOa+iTceVYG5uR5YWPe4z93Aya858W/C+/1zw74L0LT57SLT9DuYJLwSu2ZEjULhAFOSRu6kdRXb+KtOv8AVfCOqafpEsUN9dWkkMEkzEIjMpGSQCe/oacvhdhR1aueD2vxB+JOrfCnWfGUOu2+m2On3bNbs9jFJLdqXVRFyAqIu7G7DMTnmtDWPHnxJsdN8HeI5tRsLWPXruGBdDjtAwdGA+d5WywLf3VxtDDk81v6p8ItZm+A+meBNMurCK6jmR72aSR/LYb2d9pCkk7iMAgdO1bniz4eX/iDxn4Lu4J7WPRvDshllhdmErsNuzaApBAKDqR3pqyfzQb6+v8AwDGfxX4v+IPxA1zQPA+r23h/S9BIiuNRezW5lmn5BUI/yhcqw/4DnJyAMHTvjD4rg+EHiTU7qCDUtY0O/Fj9tSLEbqTjzWVcDj2wOV4652Ivhr4+8LeIvEc3gLWtFjsPEFwZ5H1GOTz7ViWJMe0FSRuON3HA4rW034e+JvAvhCw0z4e6npk1ysskupf21C5jvpHCgvlMsu3bgAZyOpOOZt7v9bldTL8Pa14m1D4f61rUHxL0/V7dLEypex6VHHLYzL8zIY+ARtBA3gHJBxgc0v2cPDutWvhRdfuNdZtO1R5pm0w2iZMu/Z5pmPzHhD8vA5z9dPQPg7f6f4H8W2N7qNnFq/icMZfsMJS1tvvYRF4O3LHJwDg9OMnqfhf4f8S+F/B8Gi+KZdJl+xKIrQ6aJOYwOrl8ZbJ7KOnfPF7N+hPRLzON+NxOs+MPAPhVAGF5qv2mYE/wR7QePoz/AJVasNcm1n9ojXI5ltX0zw3poCu9pEZY5WCk7ZSu8DBfIDAcdK3NR8Canqfxv0vxfczWp0rTLF4YIN7ecJm3AtjbjGG/vdhxWPpPwy8QWOn/ABBmnu9PbVvFLyi1kSV9kUZDhAx2ZBG/sD0FZq9vvf6Ip6v7v82eV/DTxjrl9HqOkeCfLj8U+JtUlvZ7ydB5dlbggl8MCHOS/ABx6ZrtfHnxVvfD/im08Fr4uh0h7S0STUvEE+m/aZHlIBCJAi7RkEE5GOeoxzaj+Cms6RY+B73w3d6db674eJW8kkZ1juY2YuyghCTyzjkDIc8itbU/APjTR/idqni3wDfaGw1eFEurbWFlwhUAAqYxk/dz1HXvVdUv602EurOQuvHPim6/Z68W3vioPOskn2PTr6W1+yveRSEKX8sDAG1sgjryO2a1LPV9c8A6l8KvD8d2IdI1K08i9thEh3zlQfvFdw+aQdCK6Hxz8P8AxX418DaTomo6tp89yuoLc6nLsaFGiBb93GFVjwGAGcZ25J5rnP2h4/7Rl8JaF4dkLeJjfiSyt4Cd8ceCPMyPugMq8n+6T/CcGz+a/IN18mdP4Q8W634t+LviRbS8z4V0ZRZxxrEmJbnjc2/G44w3AOPu+tcp+0Xa6nq2oeFtAttZENprF8kH2EW4J3hsecXzkgeYBt4HfPTHqPgDwZaeA/B1potoRI6DzLmfHM0zfef8+B6ACuZ+JHgHxL4g8Y+HfEvhO80xLvRS+LfVBJ5Tbu+UBP4cdBzQ0uZIE3Zsytd8TeLfD+p+Hfh3o+s2+qeJtSDzXGr3NksSW9uC2CsSfLkBT1J+7/tDEnhHxP4u0n4zXPgXxTrUPiGF7H7XFerZpbPEeOCqcY69c9ue1W/Fvw88U3Pj3SfG/hPUdKXWrSz+y3FvqEcgt5eGBYbcsPvnj2HPWtHwF8PdQ0TxDqfivxdqMWpeJNUURyNbKVgt4hjEceeSPlHJx0HHUlru/P8A4AntZeRh/tG3cp+Hdro1r80+s6lDaqCcd9/81UfjTNXu5pPjh4R8G2q2r6bpOnG8uBPaRSlSqkIUdlLIQVXlSOtdB478C6p4v8beEr+Oe1XSdFumurmGR2Ekj5UptAUg429yOtN0nwBqMfxg8Q+LtXntZLW/s1s7KOJ2MkSYUNuBUAZ29iepqV/n+Wg5Wf8AXnqeVaz8cdY17UdXfw74pj0X7LM0OlaTb6Ob2fU8dGZypVM9sdBxg4yej+MOr6ldfs2Wk3ii0W01fUHtllhxt2Sbt/Q8g7VJx2yRWh4U+H3xL8D6fN4e8O614cGitcPJFe3NvK93EG6kIPkJ9iSPem/EBZPHXxg8M+Cbb9/Z6Oy6rq74yBj7iN6Ejt6Se1Fk0l6f8Ed7Nv1PW9KR49JtEl++sKBs+uBVukFLVN3dyYqysFFFFIYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUGig0AfG+jI3w4/aRu9HW3e0s5b+SyS3RllP2eYhrf5iSccwsTndgHPORS31knxI/aZi0iQtJZi+W3khuZGUeTbrmZFKklQ3lylcY5bJwSSN/9qzw/BY+LtG12Hy1fU7Z4Zo0iClmhK/vGYfeJWVV5HAjHJHAk/ZV8L/a/EereJrmHMdhCLW2aS3yplk5ZkkPRlRcEDnE3YHmuZ8vKZ8i5+c+pBRSClqTQKKKKACvEv2q/wDklmm/9hmL/wBET17bXiX7Vf8AySzTf+wzF/6InoA8X8If8irZ/wDA/wD0Nq2qxfCH/Iq2f/A//Q2rarwKv8SXqz9oy3/caP8Ahj+SCiiiszvCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK9A+FOuaP4fvdSu9WbZPJGkNs+8DOSSUwWAGSq/McKuOWXIz5/RVwm4SUkcuMw0cXQlQk7J9i14u+E1n4ttNU8VfDOF4JIW86fw8FVmCFnG+EqTgkJnySMj5tpIMYPMeEviBG0cWn69IwlyEju26Ef7Z7Htu9+cYJPvvwR1mNbXUNInmt42MyzW6M+JJWZSHwCeQBGp4HGTmuf+JXwz0D4oDUtQ8ARW8Gv6d+8leHy0g1PezkgkHiTcr4dgN2RklWV19WLjWprn3Z+QZ5k8FiKtJQfJGzv2vtr/X4GHRXm2l+ItY8F69L4c8YwSwC0byXSVcvbnqCCPvLgggjOVwVOOD6LBcQ3UKzW00c0TfdkjYMp57EVxVKUqb1PzbF4OphZWlqu55d8U/8AkY7X/r0X/wBDevuyvhP4pf8AIyWv/Xov/ob192V6dH+Gj6/A/wC7Q9BDXi/7THgyfxD4Dt9dsRJJcaC7ySRJk7oJNokbAUklSqNnIAUOTnivaTVXUtOtdW0q607UIvOtLyF4J49xXejqVYZBBGQTyOa1Ow+ZfhPceEdZ8AXUuuaHpTXWhoTeTyafG7NCAWWQ4j5OFZcfMx2ZPLVg/BjQj48+OI1oaXDbaXpsrX7wRIY44COLeNTGoXcH2tg43CNyc8g8br1vrPw18ReJfCYuXUSj7JM6sV86LcsiSbVYgFkxwScLI6nkmvpn9nXwR/wi3w5TVbtMX+v7Lp+fuwAHyV4Yg/KxfOAf3mD92rlK6SMoU+WTfc9a6UGloqDUpW2kadZX1zfWen2tvd3ZBubiKFVkmx03sBlse9XBS0UABrJ1Xwt4f12ZJdb0LTdRkQYV7y0jmZR6AsDitaigCO3t4rWFIbaJIYowFSONQqqPQAdBUlFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFACGqH9iaV/bP9rjTLP8AtPZs+2/Z187bj7u/G7HtmtCigAFFFFABRRRQAUUUUAIaqW2lafZ3lzd2djbQXN2Q1xNFCqvMR0LsBlse9XKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOI+LPw+/wCFk+B30eK8+x3cEwurSRhmMyqrKFfgnaQ5GRyDg842k+E3w+/4Vt4HXR5bv7XdzzG6u5FGIxKyqpVOAdoCAZPJOTgZ2jt6KACiiigAooooAK8S/aq/5JZpv/YZi/8ARE9e214l+1V/ySzTf+wzF/6ImoA8a8KQyReEtPaSN0WVZHjLKQHXzXGR6jII+oNa9cNovxCn0bSraw/sHR72O3jMaPcLOrnMjuWYxypuPz4yeyqO3N//AIWvL/0KXh//AL6vP/kivMqYScpuSa1P0HB8TYShhqdKcZXiktEraL1Oqorlf+Fry/8AQpeH/wDvq8/+SKP+Fry/9Cl4f/76vP8A5IqPqVTujp/1swP8kvuX/wAkdVRXK/8AC15f+hS8P/8AfV5/8kUf8LXl/wChS8P/APfV5/8AJFH1Kp3Qf62YH+SX3L/5I6qiuV/4WvL/ANCl4f8A++rz/wCSKP8Aha8v/QpeH/8Avq8/+SKPqVTug/1swP8AJL7l/wDJHVUVyv8AwteX/oUvD/8A31ef/JFH/C15f+hS8P8A/fV5/wDJFH1Kp3Qf62YH+SX3L/5I6qiuV/4WvL/0KXh//vq8/wDkij/ha8v/AEKXh/8A76vP/kij6lU7oP8AWzA/yS+5f/JHVUVyv/C15f8AoUvD/wD31ef/ACRR/wALXl/6FLw//wB9Xn/yRR9Sqd0H+tmB/kl9y/8AkjqqK5X/AIWvL/0KXh//AL6vP/kij/ha8v8A0KXh/wD76vP/AJIo+pVO6D/WzA/yS+5f/JHVUVyv/C15f+hS8P8A/fV5/wDJFH/C15f+hS8P/wDfV5/8kUfUqndB/rZgf5Jfcv8A5I6qiuV/4WvL/wBCl4f/AO+rz/5Io/4WvL/0KXh//vq8/wDkij6lU7oP9bMD/JL7l/8AJHVUVyv/AAteX/oUvD//AH1ef/JFH/C15f8AoUvD/wD31ef/ACRR9Sqd0H+tmB/kl9y/+SOqorlf+Fry/wDQpeH/APvq8/8Akij/AIWvL/0KXh//AL6vP/kij6lU7oP9bMD/ACS+5f8AyR1VFcr/AMLXl/6FLw//AN9Xn/yRR/wteX/oUvD/AP31ef8AyRR9Sqd0H+tmB/kl9y/+SOqorlf+Fry/9Cl4f/76vP8A5Io/4WvL/wBCl4f/AO+rz/5Io+pVO6D/AFswP8kvuX/yR1VFcr/wteX/AKFLw/8A99Xn/wAkUf8AC15f+hS8P/8AfV5/8kUfUqndB/rZgf5Jfcv/AJI6qiuV/wCFry/9Cl4f/wC+rz/5Io/4WvL/ANCl4f8A++rz/wCSKPqVTug/1swP8kvuX/yR1VFcr/wteX/oUvD/AP31ef8AyRR/wteX/oUvD/8A31ef/JFH1Kp3Qf62YH+SX3L/AOSOqorlf+Fry/8AQpeH/wDvq8/+SKP+Fry/9Cl4f/76vP8A5Io+pVO6D/WzA/yS+5f/ACR1VFcr/wALXl/6FLw//wB9Xn/yRR/wteX/AKFLw/8A99Xn/wAkUfUqndB/rZgf5Jfcv/kjqqK5X/ha8v8A0KXh/wD76vP/AJIo/wCFry/9Cl4f/wC+rz/5Io+pVO6D/WzA/wAkvuX/AMkdVRXK/wDC15f+hS8P/wDfV5/8kUf8LXl/6FLw/wD99Xn/AMkUfUqndB/rZgf5Jfcv/kjqqK5X/ha8v/QpeH/++rz/AOSKP+Fry/8AQpeH/wDvq8/+SKPqVTug/wBbMD/JL7l/8kdVRXK/8LXl/wChS8P/APfV5/8AJFH/AAteX/oUvD//AH1ef/JFH1Kp3Qf62YH+SX3L/wCSOqorlf8Aha8v/QpeH/8Avq8/+SKP+Fry/wDQpeH/APvq8/8Akij6lU7oP9bMD/JL7l/8kdVRXK/8LXl/6FLw/wD99Xn/AMkUf8LXl/6FLw//AN9Xn/yRR9Sqd0H+tmB/kl9y/wDkjqqK5X/ha8v/AEKXh/8A76vP/kij/ha8v/QpeH/++rz/AOSKPqVTug/1swP8kvuX/wAkdVRXK/8AC15f+hS8P/8AfV5/8kUf8LXl/wChS8P/APfV5/8AJFH1Kp3Qf62YH+SX3L/5I6qiuV/4WvL/ANCl4f8A++rz/wCSKP8Aha8v/QpeH/8Avq8/+SKPqVTug/1swP8AJL7l/wDJHVUVyv8AwteX/oUvD/8A31ef/JFH/C15f+hS8P8A/fV5/wDJFH1Kp3Qf62YH+SX3L/5I6quu8B+IJ9BbUGgvvsqSRkygGIsQI5QrKsmA5V2Q7Q4J5G1udvk//C15f+hS8P8A/fV5/wDJFH/C15f+hS8P/wDfV5/8kVUcJVjLmTRhiOJMvxFJ0pwlZ+UX/wC3HvFz4S0j46WeoPrVxHDqenuostQsYTG6RPH8sckbA7kDhmI3k7t4VlU5bwWYeIvhJ4qudD1603KPm8oMfLmU5CzRNjocdcdiCAw43dC/aF1/w3BLFovh3w7arMwaQiG4dmIGBlmmJwPTOOT6moPF3x81/wAb+HJ9F8QaF4fmtpfmR1t5hJC4B2yI3m/KwyfYgkEEEg98YNw5amp8JmH1bE1ZeyjaDtZO3by8zl/HurWmtapZXlhJvja0UEH7yHe+VI7H/wDX0r75r83c1+imiX0+qaBp9/eWUlhcXVrHNLaS53W7MoYxnIBypODkDp0FXGKirI46VNUoKEdkXqDRRVGh5R8SfgPpfxE8XWmuvqcmluEWK+jgtlY3SqeCGyNr7cruYPwE4+XB9StbaCztYra0hjgt4UEcUUSBUjUDAVQOAAOABUtFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABQaKKAAUUUUAFFFFABRRRQAUUZooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKBRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUhrzvxL8dfAHhmNg+uR6rcbFdYNKxcFwW2/fB8sEYJIZgcDpyMgHotFfNPiX9q+dpGi8HeHo0RXUrc6q5Yuu35gYoyNp3dDvPA6c8cbPqfxq+Ium7ZrjVZLEwkEL5dhFcRyjnONgmUgf7QAPbdy0m9hOSjuz6j8Q/ETwh4W+0Lr3iLT7We12+ba+cHnXdjH7lcueGB4Xoc9Oa8p8QftV6DZXXk+HdCvNWRXdXmuJhaowBAVkGHYg8n5gpHHHJA4fQv2dpd4k8Ta0iqGIMGnqSWXbwfMcDBz22HgdeePQNC+Eng7QUXZpMd/NtKNNqH78sCc/dI2AjgZCg4+prWNCTOWeLpR21PJfEHxz+JfivT7qW2uW0vT4EjW5bR7do1jJfKs0xLOhY4XhwCBjHJz7l+zh4i1fxH8M7mbXtRuNRmttTlgimuXLybPLjfBY8t8ztySTggdAAKvxG0K88S/D7VNK0tUa7mRGiV22hikivtyehIUgZ4zjJHWvEtK8CfF/QrVrbQ21TTbd3MjRWesJCjMQAWIWUDOABn2FKdJxdkVSxEaiu9D7SpK+PP+Ef8Ajp/0Fdf/APCg/wDt1H/CP/HT/oK6/wD+FB/9uqOSXY19pDufYdFfHn/CP/HT/oK6/wD+FB/9uo/4R/46f9BXX/8AwoP/ALdRyS7B7SHc+xKK+O/+Ef8Ajp/0Fdf/APCg/wDt1ZPiGX4u+FNPS+17X9ftbaSUQq/9ts+XIJAwshPRT+VDjJboaqQeiZ9tUVwnwU1nUNf+DuhajrN3JeXkiSo88py7hJnRdx7naoyTyepJJJru6ksKKKKACiiigAooooAKKM0ZoAKKKQmkAtFcv4f8eaX4l8U65oWmxXXn6FIsV1M6qImY5GFIYkkFWByB0rpwaYeQtJRmq2o30Gl6ZdX9222C1heaVvRVBJP5CkwLVFYHgvxdY+OfDFvr2lwXUFpcM4jW6VVf5WKk4VmGMg963iaewC0V59pXjvVNV+NuseEoLe0Gk6TZpLLPsbzmlYKQM7toHzHjGeOtegA0ulw62FoozRmmAUlBNcxqvj3S9I8d6T4SmhupdS1WN5YjCqlI1UMSXJYED5WxgHpR1A6iivP9Y8d6pb/GvRfBWmW9o9pc2b3d9NKrGRFG/AUhgB90dQetd+DR0uHWwtFFFABRRRQAUUUUAFFFFABRXG/ET4oaD8M7Wxl19LyZ753WCGziDsQgBZjuZVAG5R1z8wwDyRwn/DVXgj/oF+IP/AeD/wCPUAe20V4l/wANVeCP+gX4g/8AAeD/AOPUf8NVeCP+gX4g/wDAeD/49QB7bRXiX/DVXgj/AKBfiD/wHg/+PUf8NVeCP+gX4g/8B4P/AI9QB7Ya4Txz8X/C/wAPtfsNI19rw3F6glLW8G9beMttDucg4yG4UMflPHIzxv8Aw1V4IP8AzC/EH/gPD/8AHq8P+NPj/SviP40tNX0OC8ggh09LVlvEVXLCSRiQFZhjDjv60AfWnhr4l+DfF8ixeHvENndXDuyJbOxhmcqu47Y3CuwA5yBjg88Guqr5M179naUSNJ4Z1lGUsAINQUgqu3k+YgOTntsHB68c5DT/ABl+G2WttQ1ZrKCF4Y3ST7bbRwx4+YI25Y1AAwSqkDI45FW6cl0Mo1qc9mfZVFfMuhftYX0eyPxP4agn3TjfPp8zReXFxnEb7tzD5j99QeBx1r1Xwz8dfAHiaNQmuR6VcFGdrfVcW5QBtv3yfLJOQQFcnHbg4g1PRaKitrmC8tYrm0mjnt5kWSKWJwySKRkMpHBBBBBFS0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFVtS+3f2Vd/2R9n/tDyX+y/at3lebtOzft527sZxzjOKs0UAfB/j62+IjXT3PxDh1wiO6kjSW/R/s6yMSWWI/6sA7MgJwQoxwBVHwb/wh/wDaB/4Tb+0/K82Lyvse3y8ZO/zf4tv3fuc43Y5xX38a8/174HfD3xBvebw5b2U5hMKS6cTbeX1wwRCELAnqynoAcgYpp2Ymrqxwvgmb4aSSW6eDhpIu4ndISybbonBLYMn71htJ55GMjoK7uvKPEv7KNwsjSeDvEMbozqFttVQqUXb8x82MHcdw4GwcHrxzx2o6F8Zfhpuc/wBqSWFvFJGk0DfbbZIY8ZfadwiXABBZVOM9MMK6Y10t0efUwblqpfefRFFeD6R+0VdJtTXtChlzKN0tlKY9kfGcI27cw5P3gDwOOteiaF8W/B2uouzVksJtpdodQxCVAOPvH5CT1wGJwfY1vGrCXU4p4arDodpRXK+P/Elxofw31DXNCmheVYozbzDEiYkdVDr2PDZHUdOCOK8W0rx38X9dtGudDXVNSt0cxtLZ6OkqKwAJUlYiM4IOPcUp1YxdmVSw06iuj6Tor56/4SH46f8AQK8Qf+E//wDaaP8AhIfjp/0CvEH/AIT/AP8Aaaj6xE1+oz7n0LRXz1/wkPx0/wCgV4g/8J//AO00f8JD8dP+gV4g/wDCf/8AtNH1iI/qM+59C15X+0J/yT2y/wCwnH/6Klrjf+Eg+On/AECvEH/hPj/4zWV4hi+L3irT0sde8P8AiC6to5RMqf2IyYcAgHKxg9GP51M60ZRsaUsJOE1Js+kf2ff+SFeH/wDt5/8ASmWvSa4T4KaNqPh/4O6Fp2s2klneRpLI8EowyB5ndcjsdrDIPI6EAgiu7rkPSCiiigAooooAK474reKZ/Bvwz1fWLE7buOMR27YzskdggbB443Z59K7GsrxJ4d07xX4futF1qEzWd0m11VipGDkEEdCCAfwqZXa0GtGeTaL4A0fwt8Prb4iX0l/e+JrSwOqz3sl9Jm5cxl/KfkgpkgdMnHJrjrjwnYav8BL34i+Mb67vvElyrXFreSXbr9nbzdsaIoIXGQDjHGcDGBXsfhz4R6H4eglgn1DWNbha0ayjh1a885LeFgAyRoAqqCABwM8cYrLsvgH4UtZrZJ73W7/TLWYzQaPeX2+zjfOciPaPU9Sc5Oc5q3ZtiWyuefeIH1zxXJ8JPDd3qE9vqdzb/b7i7U/vkAUFXyf49iscnnNafhHQdM0r49+MtF003UegxaNtv4nu5H82R1QsxYtndhn+bII5xivV28B6W/xEh8ZPLdG/t7P7HFDuXyUTnkLtznk98c9KZpHw90fSNe8Q6sjXVzceISPta3DqVVQCNiYAIGG7kngc0m308/xD/gf8E8U+D3h3QNK8Ba18S7jSN93p091Ppm6aTEcSR4C7d2DyWGWyeM5rG0nwL4z+Img2+rzaBI2s6jMLmPxZea5gRR7shUt05QADA4OO2OMe5+FPhJoXhLT9S060vdWvdN1GNopLC9u98EatndsRQuCc43cnjr1zT0T4K6JodzbeTrniS4sLWYTQ6VcakTaI6tuU+WqjODzgk++ael/uDWx538adUk8CeOvCniDRrtb3xLZae8V1HIjN50IUgSyBegyz9+3tUGueGNGsf2btS8UazMdY1rXTFfS329lzM7YRQAR8qB2+U8ZBOOAB69Z/C7QrbVNf1K7e71K+1+Nobq4vXV2SJhjy48KAq4wMc9B6VX/4VFoDfDMeBri51G50xHMkUssyefE27d8rBAOCT1B6mo15Wv63Hs15DPhL4A0jwb4RsbmysBb6rf2UDahKZWcyOFyRgkhcFj93ANd6eleaQ+IovhjGPDVv4f8AHviZLcBhqCWZvQwYZCiTKjCjAwAAMeua09F+IZ8Uamukf8Id4x0kXCODeahpggiiwpOS5Y4PYcHkirk+bVExVlqeSaH4nuNE8NfFP4g2jk3lzqX2Kyk2g7PmKqcd8CRTz/dFReHPhf4u1m80HU10KXQ9Rjmju73xLda6bqa8U8kLEpIXOeh9gT1z7HpXwn8N6X8O7jwWVurvS7l2kla4kHmliQd25VUZBAxx2HWovDPwn0zwzqVpeDXfEWqixBFnb6nqJlhtjtK5RAAPukjnOKUdPw/Ab1T87nnttocXxD/aA8ZPql1OmiaXbRWdzBbytF9pGPuOykHbuVyQCM4Fcl4f8T6voH7PlzDod3cQSaz4gbT9NdpDm2iKqTtb+HoRx0JJHNe+6B8OdK8O23iCOxur531+aSe6mlkQurODnYQoAA3EjINcZ408A6J4b+FWm+Frfw/r+vabDe+Y0umMr3tux3N5oG3DHJ24wBg+1JaLXy/PUe70/rTQ4rxp8OtB8MeMvA3hfw5Pdm71O8STVI3u2YXKIynzZEJxn/WYwAOGq7D4B8NeNP2lvE1tfaY1xpljarJcqbmUb7p9p3ZDZA5YYBAG3GKu/D3wNeal8WrXxY+k+ILHTNOtWRbjxLLuvr24IKbmUnIAVsDoPlGOpr0WP4V6Pb/EOXxhZX+r2d5cOHubW2u9lvcED+NQMsM843YyOnWq2av5kvql5HmVn4XtviD8f/Fs+qSzx6HottHZSQW8jRCVdgHlFlIIXKuSAeeO1dH+zWZm+HN8/mStZHVJhZRyOW8uIBeBntnP45Peuz0H4c6V4dtvEEdldXzv4gmknu5pZELozg52EKAANxIyDWh4N8Iad4H8L2+haM0721uWIe4YNI5ZixJIAHf0FKOit5Dlq/n+BvCiiigAooooAKKKKACiiigD5u/a36+Ef+33/wBoVL4X+E/grUvB+jXt7ovm3FzYQTSv9qmG52jUk4D4HJ6Cov2uP+ZR/wC33/2hUvhf4seCtO8H6NZXmteXcW1hBDKn2WY7XWNQRkJg4IPSt6PLf3jkxXtOVchq/wDCmvAf/QB/8m5//i6P+FNeA/8AoA/+Tc//AMXR/wALl8Bf9B7/AMk5/wD4ij/hcvgL/oPf+Sc//wARXT+68jg/2nzD/hTXgP8A6AP/AJNz/wDxdH/CmvAf/QB/8m5//i6P+Fy+Av8AoPf+Sc//AMRR/wALl8Bf9B7/AMk5/wD4ij915B/tPmH/AAprwH/0Af8Aybn/APi6kg+EPgW3uI5o9AjLxsHUPcSupIOeVZyCPYjBqP8A4XL4C/6D3/knP/8AEVJB8X/AtxcRwx6/GHkYIpkt5kUEnHLMgAHuSAKP3Qv9p8ztKKKK1OUx9d8JaB4ljYa5pNreMUCeayYlVQdwAkGGAz2B7n1Neeav+z1oN1vfRtTvNPkaUttlVZ40Tn5VHytxxgljwOc5zXoeu+LtA8NIW1zVra0YIHETPmVlLbQRGMswznkDsfSvP9d/aB8P2DmPQ7G51Z1YDzGPkRMpXJIJBbIOBgqO5z0zjP2f2jqpfWPsXOLt/h78UfAF0914XupdqqtxK+lXnyyFCSFeJtplI5+UqwO7HOSK2NH/AGkPHvhjUDZeMdPh1Mo5aaK6g+x3KgoNqgqAqjOG5jJIJ55GMdvib8TfG1vLD4a06fbCpW4bRdPkkYBwQu5vnKHhsFSp6+gxs6N+zf498T6gb3xjqEOmF3KzSXU/2u5YBBtYBWKsM4XmQEAHjgZ458n2T1qftLfvLHrfgj9oTwn4y1my0Z4bzSdRu0AUXYTyWm4/dJIGySTnaSq7sY4JCn1cV5J4B/Z48NeC9VtNYvLq41rVLXLI06KkCPuysixckMo6EswB+YAHGPWxUGoUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFBoooA5/xN4E8MeMI2XxJodnfuyLGJ3j2zKobcFWVcOozngEdT6mvKde/ZV8NXm+Tw/rOoaXK8xfZOq3MSIc/Iq/K3GRgs7HA5yTmvdqKAPjbWPgL8TvDtnd29jbrqVhLCJroaZeZSTYSQhjbY8jDGQArdRjnivbv2b/AA7q/hz4Z3MOvadcadNc6nLPHDcpskKeXGmSp5XlG4IBwAehBPrdFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcb8RPhfoPxMtbGLX3vIXsXdoJrOUI4DgBlO5WUg7VPTPyjBGTnhP+GVfBB/5iviD/wIg/8AjNe20UAeJf8ADKngj/oK+IP/AAIh/wDjNH/DKngj/oK+IP8AwIh/+M17bRQB4l/wyp4I/wCgr4g/8CIf/jNH/DKngj/oK+IP/AiH/wCM17bRQB4l/wAMq+CB/wAxTX//AAIh/wDjNeHfGnwBpXw48aWmkaHPeT282npdM146MwcySKQCqqMYQdvWvt01wHxB+DXhr4kapa6jrcuoW13bQ/ZxJZTKu+PcWAYOrDgsxBAB+Y5zxgA8Q1r9oofvo/D2hZ+75M99L9N26NfxAw/ofasSzufjJ8SpFutEi1UWpEksMlofsVuV3BSqykqHweACzMMN/tV9QeGvhp4N8ISLL4e8PWdtcK7Oly6maZCy7TtkkLOoI4wCByeOTXU1bqSZjGjThsj5i0D9lHVZbvd4q8Q2dvbo6Hy9ORpnlXJ3jc4QIcYwcP15HGD6r4e+AXw98P8A2d/7F/tO5g3fv9SlM3mbs/ej4iOAcD5OMA9ea9JoqDYitraCztYrW0hjgt4EWOKKJAqRqBgKoHAAAAAFS0UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB/9k="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![prediction.jpg](attachment:prediction.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "L_M87dhkgGI-"
   },
   "outputs": [],
   "source": [
    "eval_examples = read_squad_examples(\"/content/dev-v1.1.json\",False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 122
    },
    "colab_type": "code",
    "id": "nzCLI0J_VvFs",
    "outputId": "c6f3839d-3dc5-432d-e38b-2946e1d1ef3c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of eval  <class 'list'>\n",
      "------------------------------------------------------------\n",
      "56be4db0acb8001400a502ec\n",
      "------------------------------------------------------------\n",
      "['Super', 'Bowl', '50', 'was', 'an', 'American', 'football', 'game', 'to', 'determine', 'the', 'champion', 'of', 'the', 'National', 'Football', 'League', '(NFL)', 'for', 'the', '2015', 'season.', 'The', 'American', 'Football', 'Conference', '(AFC)', 'champion', 'Denver', 'Broncos', 'defeated', 'the', 'National', 'Football', 'Conference', '(NFC)', 'champion', 'Carolina', 'Panthers', '24–10', 'to', 'earn', 'their', 'third', 'Super', 'Bowl', 'title.', 'The', 'game', 'was', 'played', 'on', 'February', '7,', '2016,', 'at', \"Levi's\", 'Stadium', 'in', 'the', 'San', 'Francisco', 'Bay', 'Area', 'at', 'Santa', 'Clara,', 'California.', 'As', 'this', 'was', 'the', '50th', 'Super', 'Bowl,', 'the', 'league', 'emphasized', 'the', '\"golden', 'anniversary\"', 'with', 'various', 'gold-themed', 'initiatives,', 'as', 'well', 'as', 'temporarily', 'suspending', 'the', 'tradition', 'of', 'naming', 'each', 'Super', 'Bowl', 'game', 'with', 'Roman', 'numerals', '(under', 'which', 'the', 'game', 'would', 'have', 'been', 'known', 'as', '\"Super', 'Bowl', 'L\"),', 'so', 'that', 'the', 'logo', 'could', 'prominently', 'feature', 'the', 'Arabic', 'numerals', '50.']\n"
     ]
    }
   ],
   "source": [
    "print(\"type of eval \",type(eval_examples))\n",
    "print(\"-\"*60)\n",
    "print(eval_examples[0].qas_id)\n",
    "print(\"-\"*60)\n",
    "print(eval_examples[0].doc_tokens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "r9slcIN5rMTg"
   },
   "outputs": [],
   "source": [
    "eval_writer = run_squad.FeatureWriter(\n",
    "    filename=os.path.join(OUTPUT_DIR, \"eval.tf_record\"),\n",
    "    is_training=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tRjCtUFDs2YJ"
   },
   "outputs": [],
   "source": [
    "\n",
    "def append_feature(feature):\n",
    "    eval_features.append(feature)\n",
    "    eval_writer.process_feature(feature)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "eMAfkf8mtBvx",
    "outputId": "151395cb-e8a0-415e-a269-f02ff0744d32"
   },
   "outputs": [],
   "source": [
    "eval_features = []\n",
    "\n",
    "run_squad.convert_examples_to_features(\n",
    "        examples=eval_examples,\n",
    "        tokenizer=tokenizer,\n",
    "        max_seq_length=MAX_SEQ_LENGTH,\n",
    "        doc_stride=128,\n",
    "        max_query_length=64,\n",
    "        is_training=False,\n",
    "        output_fn=append_feature)\n",
    "\n",
    "eval_writer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "95IThsb7fFj1",
    "outputId": "5bb4d170-7e69-4dd0-a258-7d538031ca1a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10570\n",
      "12006\n"
     ]
    }
   ],
   "source": [
    "print(len(eval_examples))\n",
    "print(len(eval_features))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "tpylUVXBtomL",
    "outputId": "230cdbe7-ca9d-4701-b606-5ae0bbadf8db"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I0827 06:25:10.172574 140491252946816 <ipython-input-47-84a684c96aaa>:1] ***** Running predictions *****\n",
      "I0827 06:25:10.174535 140491252946816 <ipython-input-47-84a684c96aaa>:2]   Num orig examples = 10570\n",
      "I0827 06:25:10.175938 140491252946816 <ipython-input-47-84a684c96aaa>:3]   Num features = 12006\n"
     ]
    }
   ],
   "source": [
    "tf.logging.info(\"***** Running predictions *****\")\n",
    "tf.logging.info(\"  Num orig examples = %d\", len(eval_examples))\n",
    "tf.logging.info(\"  Num features = %d\", len(eval_features))\n",
    "\n",
    "predict_input_fn = run_squad.input_fn_builder(\n",
    "    input_file=eval_writer.filename,\n",
    "    seq_length=MAX_SEQ_LENGTH,\n",
    "    is_training=False,\n",
    "    drop_remainder=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "eNZ9qVjEttui",
    "outputId": "a84e64f1-20c4-4ec5-e1e8-55baffe45b35"
   },
   "outputs": [],
   "source": [
    "all_results = []\n",
    "for result in estimator.predict(predict_input_fn, yield_single_examples=True):\n",
    "    if len(all_results) % 1000 == 0:\n",
    "        tf.logging.info(\"Processing example: %d\" % (len(all_results)))\n",
    "    unique_id = int(result[\"unique_ids\"])\n",
    "    start_logits = [float(x) for x in result[\"start_logits\"].flat]\n",
    "    end_logits = [float(x) for x in result[\"end_logits\"].flat]\n",
    "    all_results.append(\n",
    "          run_squad.RawResult(\n",
    "              unique_id=unique_id,\n",
    "              start_logits=start_logits,\n",
    "              end_logits=end_logits))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8j1A-vtSt5gu"
   },
   "outputs": [],
   "source": [
    "output_prediction_file = os.path.join(OUTPUT_DIR, \"predictions.json\")\n",
    "output_nbest_file = os.path.join(OUTPUT_DIR, \"nbest_predictions.json\")\n",
    "output_null_log_odds_file = os.path.join(OUTPUT_DIR, \"null_odds.json\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iPhJ3ayze1o4"
   },
   "outputs": [],
   "source": [
    "import collections\n",
    "import json\n",
    "\n",
    "write_predictions(eval_examples, eval_features, all_results,\n",
    "                      20, 30,\n",
    "                      True, output_prediction_file,\n",
    "                      output_nbest_file, output_null_log_odds_file)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "w5sL74Tg30_w"
   },
   "source": [
    "### F1 Score Calcualtion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LfaLVsUE-N14"
   },
   "outputs": [],
   "source": [
    "# please refer https://github.com/allenai/bi-att-flow/blob/master/squad/evaluate-v1.1.py#L86\n",
    "import re\n",
    "from collections import Counter\n",
    "def normalize_answer(s):\n",
    "    \"\"\"Lower text and remove punctuation, articles and extra whitespace.\"\"\"\n",
    "    def remove_articles(text):\n",
    "        return re.sub(r'\\b(a|an|the)\\b', ' ', text)\n",
    "\n",
    "    def white_space_fix(text):\n",
    "        return ' '.join(text.split())\n",
    "\n",
    "    def remove_punc(text):\n",
    "        exclude = set(string.punctuation)\n",
    "        return ''.join(ch for ch in text if ch not in exclude)\n",
    "\n",
    "    def lower(text):\n",
    "        return text.lower()\n",
    "\n",
    "    return white_space_fix(remove_articles(remove_punc(lower(s))))\n",
    "  \n",
    "def f1_score(prediction, ground_truth):\n",
    "    prediction_tokens = normalize_answer(prediction).split()\n",
    "    ground_truth_tokens = normalize_answer(ground_truth).split()\n",
    "    common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\n",
    "    num_same = sum(common.values())\n",
    "    if num_same == 0:\n",
    "        return 0\n",
    "    precision = 1.0 * num_same / len(prediction_tokens)\n",
    "    recall = 1.0 * num_same / len(ground_truth_tokens)\n",
    "    f1 = (2 * precision * recall) / (precision + recall)\n",
    "    return f1\n",
    "\n",
    "\n",
    "def exact_match_score(prediction, ground_truth):\n",
    "    return (normalize_answer(prediction) == normalize_answer(ground_truth))\n",
    "\n",
    "\n",
    "def metric_max_over_ground_truths(metric_fn, prediction, ground_truths):\n",
    "    scores_for_ground_truths = []\n",
    "    for ground_truth in ground_truths:\n",
    "        score = metric_fn(prediction, ground_truth)\n",
    "        scores_for_ground_truths.append(score)\n",
    "    return max(scores_for_ground_truths)\n",
    "\n",
    "\n",
    "def evaluate(dataset, predictions):\n",
    "    f1 = exact_match = total = 0\n",
    "    for article in dataset:\n",
    "        for paragraph in article['paragraphs']:\n",
    "            for qa in paragraph['qas']:\n",
    "                total += 1\n",
    "                if qa['id'] not in predictions:\n",
    "#                     message = 'Unanswered question ' + qa['id'] + \\\n",
    "#                               ' will receive score 0.'\n",
    "#                     print(message, file=sys.stderr)\n",
    "                    continue\n",
    "                ground_truths = list(map(lambda x: x['text'], qa['answers']))\n",
    "                prediction = predictions[qa['id']]\n",
    "                exact_match += metric_max_over_ground_truths(\n",
    "                    exact_match_score, prediction, ground_truths)\n",
    "                f1 += metric_max_over_ground_truths(\n",
    "                    f1_score, prediction, ground_truths)\n",
    "\n",
    "    exact_match = 100.0 * exact_match / total\n",
    "    f1 = 100.0 * f1 / total\n",
    "\n",
    "    return {'exact_match': exact_match, 'f1': f1}\n",
    "  \n",
    "  \n",
    "def evaluate_squad(data_file,pred_file):\n",
    "  \n",
    "  with open(data_file) as dataset_file:\n",
    "    dataset_json = json.load(dataset_file)\n",
    "    dataset = dataset_json['data']\n",
    "  with open(pred_file) as prediction_file:\n",
    "    predictions = json.load(prediction_file)\n",
    "  print(evaluate(dataset, predictions))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "QDL05DC0my7g",
    "outputId": "d97e6f90-4c39-49e9-d473-97e01b43b834"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'exact_match': 80.85146641438033, 'f1': 88.0228956599229}\n"
     ]
    }
   ],
   "source": [
    "evaluate_squad(\"/content/dev-v1.1.json\",\"/content/bert-checkpoints_models_SQUAD_predictions.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "IplHdvPsr851",
    "outputId": "34eda63b-5753-4144-8f42-ae2536ee9afb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'exact_match': 84.38978240302744,'f1': 90.87081895814865}\n"
     ]
    }
   ],
   "source": [
    "evaluate_squad(\"/content/train-v1.1.json\",\"/content/bert-checkpoints_models_SQUAD_train_predictions.json\")"
   ]
  }
 ],
 "metadata": {
  "accelerator": "TPU",
  "colab": {
   "collapsed_sections": [],
   "name": "raman.shinde15@gmail.com_bert.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
